import { FetchService } from '@/utils'
/**
 *
 * @class
 */
export default class {
	public http: FetchService
	public constructor(http: FetchService) {
		this.http = http
	}

	/**
	 * getMultRuleResult
	 * @method
	 * @name #GetMultRuleResultExecuteRuleApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetMultRuleResultExecuteRuleApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RuleResultBo$> {
		let path = ''
		path = '/ego_api/api/rule/execute/getMultRuleResult'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RuleResultBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * getRuleResult
	 * @method
	 * @name #GetRuleResultExecuteRuleApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetRuleResultExecuteRuleApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RuleResultBo$> {
		let path = ''
		path = '/ego_api/api/rule/execute/getRuleResult'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RuleResultBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * client端加群
	 * @method
	 * @name #AddChatChatV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async AddChatChatV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/chat/addChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * client端创建群
	 * @method
	 * @name #CreateChatChatV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async CreateChatChatV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/chat/createChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * api获取群相关信息
	 * @method
	 * @name #GetChatInfoChatV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetChatInfoChatV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/chat/getChatInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * api端获取群名称以及群描述
	 * @method
	 * @name #GetChatNameChatV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetChatNameChatV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/chat/getChatName'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * client端获取加群干系人列表
	 * @method
	 * @name #GetChatPremissionChatV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetChatPremissionChatV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/chat/getChatPremission'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 代理待办查询
	 * @method
	 * @name #AgentToDoTaskByPageCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async AgentToDoTaskByPageCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskBeanDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/agentToDoTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskBeanDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取代理待办委托人和数量
	 * @method
	 * @name #AgentToDoTaskUserCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async AgentToDoTaskUserCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$AgentResultVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/agentToDoTaskUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$AgentResultVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 批量同意执行
	 * @method
	 * @name #BatchGeneralRunProcessCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async BatchGeneralRunProcessCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$ExecuteLog$$> {
		let path = ''
		path = '/ego_api/api/v1/common/batchGeneralRunProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$ExecuteLog$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除评论接口
	 * @method
	 * @name #DeleteCommentCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DeleteCommentCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/common/deleteComment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * deleteProcessInfoCache
	 * @method
	 * @name #DeleteProcessInfoCacheCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DeleteProcessInfoCacheCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/common/deleteProcessInfoCache'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除回复评论接口
	 * @method
	 * @name #DeleteReplyCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DeleteReplyCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/common/deleteReply'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办查询分页列表
	 * @method
	 * @name #DoneTaskByPageCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DoneTaskByPageCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskBeanDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/doneTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskBeanDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办查询数量
	 * @method
	 * @name #DoneTaskCountCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DoneTaskCountCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/doneTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程key分组，获取已办数量
	 * @method
	 * @name #DoneTaskCountByTypeCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DoneTaskCountByTypeCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskCountDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/doneTaskCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskCountDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 预计待办查询
	 * @method
	 * @name #ExpectTaskByPageCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ExpectTaskByPageCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$PortalExpectTaskResultVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/expectTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$PortalExpectTaskResultVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 预计待办查询数量
	 * @method
	 * @name #ExpectTaskByPageCountCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ExpectTaskByPageCountCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/api/v1/common/expectTaskByPageCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据登录人获取代理知会列表
	 * @method
	 * @name #GetAgentNoticeByUserIdCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetAgentNoticeByUserIdCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskBeanDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getAgentNoticeByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskBeanDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据登录人获取代理未读知会数量
	 * @method
	 * @name #GetAgentNoticeCountByUserIdCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetAgentNoticeCountByUserIdCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/getAgentNoticeCountByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * API获取auth接口
	 * @method
	 * @name #GetAuthCommonV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetAuthCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$CacheUserBean$> {
		let path = ''
		path = '/ego_api/api/v1/common/getAuth'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$CacheUserBean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取预计待办任务单据类型筛选接口
	 * @method
	 * @name #GetExpectTaskTypeCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetExpectTaskTypeCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$MapObject$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getExpectTaskType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$MapObject$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程预测查询
	 * @method
	 * @name #GetFlowVirtualInfoForecastCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetFlowVirtualInfoForecastCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskListResultForecast$> {
		let path = ''
		path = '/ego_api/api/v1/common/getFlowVirtualInfoForecast'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskListResultForecast$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 我的申请查询
	 * @method
	 * @name #GetMyApplicationCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetMyApplicationCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$MyApplicationVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getMyApplication'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$MyApplicationVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 我的申请查询数量
	 * @method
	 * @name #GetMyApplicationCountCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetMyApplicationCountCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/getMyApplicationCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据noticeId获取知会详细信息接口
	 * @method
	 * @name #GetNoticeByIdCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetNoticeByIdCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$FlowTaskNoticeInfoResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getNoticeById'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$FlowTaskNoticeInfoResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据登录人获取未读/已读知会数量
	 * @method
	 * @name #GetNoticeCountByUserIdCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetNoticeCountByUserIdCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/getNoticeCountByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据登录人获取已读(含代理已读知会)/未读知会列表
	 * @method
	 * @name #GetNoticeListPageByUserIdCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetNoticeListPageByUserIdCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskBeanDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getNoticeListPageByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskBeanDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程实例信息
	 * @method
	 * @name #GetProcessInstanceCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetProcessInstanceCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$ProcessInstanceResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ProcessInstanceResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程图SVG
	 * @method
	 * @name #GetProcessSvgCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetProcessSvgCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/api/v1/common/getProcessSvg'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例ID获取已读未读信息
	 * @method
	 * @name #GetReadInfoCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetReadInfoCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$NoticeIsReadResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getReadInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$NoticeIsReadResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 新撤回revoke获取可撤回节点接口
	 * @method
	 * @name #GetRevokeScreeningTaskCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetRevokeScreeningTaskCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$RevokeTaskVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getRevokeScreeningTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$RevokeTaskVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取可退回节点列表
	 * @method
	 * @name #GetRollBackNodeListCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetRollBackNodeListCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/common/getRollBackNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可退回任务
	 * @method
	 * @name #GetRollBackScreeningTaskCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetRollBackScreeningTaskCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$RollBackTaskVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/getRollBackScreeningTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$RollBackTaskVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务按钮
	 * @method
	 * @name #GetTaskBtnCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetTaskBtnCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskBtnResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getTaskBtn'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskBtnResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过任务ID获取流程实例ID和当前任务节点和表单地址
	 * @method
	 * @name #GetTaskInfoCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetTaskInfoCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskInfoResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getTaskInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskInfoResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过任务ID获取任务信息
	 * @method
	 * @name #GetTaskInstanceCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetTaskInstanceCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskInstanceVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getTaskInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程审批记录
	 * @method
	 * @name #GetTaskProcessCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetTaskProcessCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskProcessListVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/getTaskProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskProcessListVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminCommonV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GrantAuthToAdminCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskInfoResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskInfoResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 手动发起预览
	 * @method
	 * @name #RunCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RunCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$TaskListResultForecast$> {
		let path = ''
		path = '/ego_api/api/v1/common/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskListResultForecast$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 驱动接收任务节点(未传nodeId时，默认取第一个接收任务节点)
	 * @method
	 * @name #RunReceiveTaskCommonV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async RunReceiveTaskCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RunProcessResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/runReceiveTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RunProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通用执行(同意、撤回、终止、转办、退回指定步骤、暂存待办、保存草稿、加签、指定任务退回、代理执行)
	 * @method
	 * @name #RunTaskProcessCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RunTaskProcessCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RunProcessResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/runTaskProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RunProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加评论接口
	 * @method
	 * @name #SaveCommentCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SaveCommentCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$SaveCommentVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/saveComment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SaveCommentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加评论回复接口
	 * @method
	 * @name #SaveReplyCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SaveReplyCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$SaveCommentReplyVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/saveReply'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SaveCommentReplyVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取评论列表接口（包含回复列表 pc端调用）
	 * @method
	 * @name #SelectCommentListCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SelectCommentListCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/api/v1/common/selectCommentList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 移动端获取评论列表，包含评论数量
	 * @method
	 * @name #SelectCommentListAndReplyCountCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SelectCommentListAndReplyCountCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$CommentVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/selectCommentListAndReplyCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$CommentVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 移动端获取回复列表
	 * @method
	 * @name #SelectReplyListCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SelectReplyListCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$CommentReplyVo$$> {
		let path = ''
		path = '/ego_api/api/v1/common/selectReplyList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$CommentReplyVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询分享链接接口
	 * @method
	 * @name #SelectShareCommonV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectShareCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$ShareResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/selectShare'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ShareResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 发送知会
	 * @method
	 * @name #SendRepeatNoticeCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SendRepeatNoticeCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/sendRepeatNotice'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置知会为已读
	 * @method
	 * @name #SetTaskNoticeReadCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SetTaskNoticeReadCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/api/v1/common/setTaskNoticeRead'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 简易执行(只需传入任务ID、审批人、按钮类型)
	 * @method
	 * @name #SimpleRunCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async SimpleRunCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RunProcessResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/simpleRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RunProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 启动并提交
	 * @method
	 * @name #StartProcessAndSubmitCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async StartProcessAndSubmitCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$StartProcessResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/common/startProcessAndSubmit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$StartProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程手动结束
	 * @method
	 * @name #TerminateRunProcessCommonV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async TerminateRunProcessCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/common/terminateRunProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 待办查询
	 * @method
	 * @name #ToDoTaskByPageCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ToDoTaskByPageCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskBeanDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/toDoTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskBeanDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 待办查询数量
	 * @method
	 * @name #ToDoTaskCountCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ToDoTaskCountCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/api/v1/common/toDoTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程key分组，获取待办数量
	 * @method
	 * @name #ToDoTaskCountByTypeCommonV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ToDoTaskCountByTypeCommonV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$TaskCountDto$$> {
		let path = ''
		path = '/ego_api/api/v1/common/toDoTaskCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$TaskCountDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除没有流程实例的process key
	 * @method
	 * @name #DeleteProcessInstanceByProcessKeyManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async DeleteProcessInstanceByProcessKeyManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/manager/deleteProcessInstanceByProcessKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 重新插入瞬时变量
	 * @method
	 * @name #InsertTransientVariableManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async InsertTransientVariableManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/manager/insertTransientVariable'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作批量终止
	 * @method
	 * @name #ManagerBatchEndFlowProcessManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ManagerBatchEndFlowProcessManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/manager/managerBatchEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理执行(终止)
	 * @method
	 * @name #ManagerEndFlowProcessManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async ManagerEndFlowProcessManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/manager/managerEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询定义流程实例每个版本个数
	 * @method
	 * @name #QueryProcessInstanceNumManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async QueryProcessInstanceNumManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$FixflowProcessDesignerVo$$> {
		let path = ''
		path = '/ego_api/api/v1/manager/queryProcessInstanceNum'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$FixflowProcessDesignerVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询定义流程版本
	 * @method
	 * @name #QueryProcessVersionManagerV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async QueryProcessVersionManagerV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$FixflowDefProcessdefinitionVo$$> {
		let path = ''
		path = '/ego_api/api/v1/manager/queryProcessVersion'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$FixflowDefProcessdefinitionVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * sign判断用户是否为流程干系人
	 * @method
	 * @name #HasPermissionPermissionV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async HasPermissionPermissionV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/permission/hasPermission'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-批量终止
	 * @method
	 * @name #BatchEndFlowProcessCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async BatchEndFlowProcessCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TerminateProcessParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/batchEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 批量转发
	 * @method
	 * @name #BatchTransferCommandPrivateV1ApiEgo_apiPOST
	 * @param {} transferParam - transferParam
	 */
	public async BatchTransferCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/batchTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-任务列表
	 * @method
	 * @name #TransferListDoneCommandPrivateV1ApiEgo_apiPOST
	 * @param {} transferParam - transferParam
	 */
	public async TransferListDoneCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.ListResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/done/transferList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办任务交接转办
	 * @method
	 * @name #DoneTransferCommandPrivateV1ApiEgo_apiPOST
	 * @param {} transferParam - transferParam
	 */
	public async DoneTransferCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.PlainResult$ExecuteLog$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/doneTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ExecuteLog$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-重新计算流程预览
	 * @method
	 * @name #ForecastRunCommandPrivateV1ApiEgo_apiPOST
	 * @param {} req - req
	 */
	public async ForecastRunCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/forecastRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取可重启的节点列表
	 * @method
	 * @name #GetAllNodeListCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async GetAllNodeListCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/getAllNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取指定历史节点列表
	 * @method
	 * @name #GetRollbackHistoryNodeListCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async GetRollbackHistoryNodeListCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodesParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/getRollbackHistoryNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async GrantAuthToAdminCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodesParam
	}): Promise<typing.delegate.PlainResult$TaskInfoResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$TaskInfoResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-流程人员流转
	 * @method
	 * @name #ManagerArbitrarilyProcessCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerArbitrarilyProcessCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerArbitrarilyProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-加签
	 * @method
	 * @name #ManagerEndorsementProcessCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerEndorsementProcessCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskEndorseRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerEndorsementProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-重启
	 * @method
	 * @name #ManagerRestartProcessCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerRestartProcessCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerRestartProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回指定历史节点
	 * @method
	 * @name #ManagerRollbackToHistoryNodeCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerRollbackToHistoryNodeCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodeParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerRollbackToHistoryNode'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回上一步
	 * @method
	 * @name #ManagerRollbackToLastCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerRollbackToLastCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerRollbackToLast'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-跳过
	 * @method
	 * @name #ManagerSkipProcessCommandPrivateV1ApiEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerSkipProcessCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/managerSkipProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 待办任务交接转办
	 * @method
	 * @name #TodoTransferCommandPrivateV1ApiEgo_apiPOST
	 * @param {} transferParam - transferParam
	 */
	public async TodoTransferCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.PlainResult$ExecuteLog$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/todoTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ExecuteLog$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-查询瞬时变量
	 * @method
	 * @name #TransientVariableCommandPrivateV1ApiEgo_apiPOST
	 * @param {} req - req
	 */
	public async TransientVariableCommandPrivateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_api/api/v1/private/command/transientVariable'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * approvalChain
	 * @method
	 * @name #ApprovalChainSimulateV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async ApprovalChainSimulateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/api/v1/simulate/approvalChain'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 删除流程定义及数据
	 * @method
	 * @name #DeleteDeploymentSimulateV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async DeleteDeploymentSimulateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/simulate/deleteDeployment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * getSimulateResult
	 * @method
	 * @name #GetSimulateResultSimulateV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetSimulateResultSimulateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$SimulateResultVo$> {
		let path = ''
		path = '/ego_api/api/v1/simulate/getSimulateResult'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SimulateResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * run
	 * @method
	 * @name #RunSimulateV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async RunSimulateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/api/v1/simulate/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * terminate
	 * @method
	 * @name #TerminateSimulateV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async TerminateSimulateV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/simulate/terminate'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加或者更新流程单据（定义）信息
	 * @method
	 * @name #AddOrUpdateProcessInfoUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async AddOrUpdateProcessInfoUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/addOrUpdateProcessInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加外部流程实例
	 * @method
	 * @name #AddProcessInstanceUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async AddProcessInstanceUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/addProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加任务实例
	 * @method
	 * @name #AddTaskUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async AddTaskUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/addTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 覆盖更新任务数据
	 * @method
	 * @name #CoverTaskDataUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async CoverTaskDataUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/coverTaskData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除流程实例或任务实例
	 * @method
	 * @name #DeleteInstUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async DeleteInstUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/deleteInst'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 撤销任务实例
	 * @method
	 * @name #RevocationTaskUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async RevocationTaskUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/revocationTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 更新流程实例
	 * @method
	 * @name #UpdateProcessInstanceUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async UpdateProcessInstanceUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/updateProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 更新任务实例
	 * @method
	 * @name #UpdateTaskUnifyV1ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async UpdateTaskUnifyV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v1/unify/updateTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 催办建群
	 * @method
	 * @name #CreateChatUrgentV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async CreateChatUrgentV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/urgent/createChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取到流程所在的待审批人员信息
	 * @method
	 * @name #GetUrgentTodoInfoUrgentV1ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetUrgentTodoInfoUrgentV1ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v1/urgent/getUrgentTodoInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #ListDataVariableV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async ListDataVariableV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/dataVariable/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程预测
	 * @method
	 * @name #GetForecastV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetForecastV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/forecast/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取模拟运行的入参
	 * @method
	 * @name #TransientVariableForecastV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async TransientVariableForecastV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/forecast/transientVariable'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作批量终止
	 * @method
	 * @name #BatchEndFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async BatchEndFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/batchEnd'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作批量转发(同步)
	 * @method
	 * @name #BatchTransferFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async BatchTransferFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/batchTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-删除工作交接
	 * @method
	 * @name #DelHandoverFlowManagerV2ApiEgo_apiPOST
	 * @param {} req - req
	 */
	public async DelHandoverFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/delHandover'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理执行(终止)
	 * @method
	 * @name #EndFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async EndFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/end'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-工作交接
	 * @method
	 * @name #HandoverFlowManagerV2ApiEgo_apiPOST
	 * @param {} req - req
	 */
	public async HandoverFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/handover'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作重启
	 * @method
	 * @name #RestartFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RestartFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/restart'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-退回指定历史节点
	 * @method
	 * @name #RollbackFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RollbackFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/rollback'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-查询可退回指定历史节点列表
	 * @method
	 * @name #RollbackNodeListFlowManagerV2ApiEgo_apiPOST
	 * @param {} req - req
	 */
	public async RollbackNodeListFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRollBackRequestVo
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/rollbackNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作跳过，退回上一步
	 * @method
	 * @name #RunTaskFlowManagerV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RunTaskFlowManagerV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/manager/flow/runTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 判断用户是否为流程干系人
	 * @method
	 * @name #HasPermissionV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async HasPermissionV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/permission/has'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发布流程
	 * @method
	 * @name #BatchDeploymentDefProcessV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async BatchDeploymentDefProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/process/def/batchDeployment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程定义id清空本地流程定义的缓存
	 * @method
	 * @name #CleanCacheDefProcessV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async CleanCacheDefProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/process/def/cache/clean'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id获取bpmn的xml文件
	 * @method
	 * @name #GetBpmnDefProcessV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetBpmnDefProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/process/def/getBpmn'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发布流程的契约锁配置
	 * @method
	 * @name #PublishExtendConfigDefProcessV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async PublishExtendConfigDefProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v2/process/def/publishExtendConfig'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除流程实例数据(不触发流程结束/终止事件)
	 * @method
	 * @name #DeleteProcessInstanceInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async DeleteProcessInstanceInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/deleteProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程实例填充后的数据
	 * @method
	 * @name #GetFillInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetFillInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$ProcessInsFillVo$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/getFill'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ProcessInsFillVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询百搭特平台指定流程实例的审批数据
	 * @method
	 * @name #SelectPlatformTaskListInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectPlatformTaskListInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$PlatformProcessVo$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/selectPlatformTaskList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$PlatformProcessVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程查询
	 * @method
	 * @name #SelectProInstPageInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectProInstPageInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PageResult$ProcessInstanceVo$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/selectProInstPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ProcessInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务查询
	 * @method
	 * @name #SelectTaskInstPageInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectTaskInstPageInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PageResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/selectTaskInstPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询百搭特平台的审批数据
	 * @method
	 * @name #SelectTaskListInsProcessV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectTaskListInsProcessV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$WorkFlowRequestDto$$> {
		let path = ''
		path = '/ego_api/api/v2/process/ins/selectTaskList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$WorkFlowRequestDto$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据节点id和流程定义id判断是否存在任务
	 * @method
	 * @name #ExistTaskV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async ExistTaskV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$List$string$$> {
		let path = ''
		path = '/ego_api/api/v2/task/exist'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$string$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程定义返回所有节点ID
	 * @method
	 * @name #GetExistNodeListTaskV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetExistNodeListTaskV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/api/v2/task/getExistNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 重新提交
	 * @method
	 * @name #RestSubmitTaskV2ApiEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async RestSubmitTaskV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse$RunProcessResultVo$> {
		let path = ''
		path = '/ego_api/api/v2/task/restSubmit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$RunProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程实例的瞬时变量
	 * @method
	 * @name #GetTransientVariableV2ApiEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetTransientVariableV2ApiEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/api/v2/transientVariable/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 检查是否显示逐条队列组件(上一条、下一条)
	 * @method
	 * @name #CheckQueueApproveV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async CheckQueueApproveV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CheckApproveQueueReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/approve/queue/check'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询上一条/下一条待办链接
	 * @method
	 * @name #GetQueueApproveV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetQueueApproveV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.GetApproveQueueReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/approve/queue/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 创建群
	 * @method
	 * @name #CreateChatV2AuthEgo_apiPOST
	 * @param {} clientChatVo - clientChatVo
	 */
	public async CreateChatV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CreateChatReq
	}): Promise<typing.delegate.ApiResponse$ChatInfoVo$> {
		let path = ''
		path = '/ego_api/auth/v2/chat/create'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatInfoVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取群相关信息
	 * @method
	 * @name #GetChatV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetChatV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$ChatMessageVo$> {
		let path = ''
		path = '/ego_api/auth/v2/chat/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatMessageVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取群名称以及群描述
	 * @method
	 * @name #GetNameChatV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetNameChatV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$ChatNameVo$> {
		let path = ''
		path = '/ego_api/auth/v2/chat/getName'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatNameVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 加群
	 * @method
	 * @name #JoinChatV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async JoinChatV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.AddChatReq
	}): Promise<typing.delegate.ApiResponse$ChatInfoVo$> {
		let path = ''
		path = '/ego_api/auth/v2/chat/join'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatInfoVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取加群干系人列表
	 * @method
	 * @name #ListPermissionChatV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async ListPermissionChatV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$List$ChatPermissionVo$$> {
		let path = ''
		path = '/ego_api/auth/v2/chat/permission/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$ChatPermissionVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加评论
	 * @method
	 * @name #AddCommentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async AddCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$SaveCommentVo$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/add'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SaveCommentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除评论
	 * @method
	 * @name #DeleteCommentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据文件id删除文件
	 * @method
	 * @name #DeleteFileCommentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteFileCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.DeleteCommentFileReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/file/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * download
	 * @method
	 * @name #DownloadFileCommentV2AuthEgo_apiGET
	 * @param {string} fileId - fileId
	 * @param {string} processInstanceId - processInstanceId
	 * @param {string} token - token
	 */
	public async DownloadFileCommentV2AuthEgo_apiGET(params: {
		query?: {
			fileId?: string
			processInstanceId?: string
			token?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_api/auth/v2/comment/file/download'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['fileId'] !== undefined) {
			queryParameters['fileId'] = params.query['fileId']
		}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		if (params.query?.['token'] !== undefined) {
			queryParameters['token'] = params.query['token']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 生成文件下载token
	 * @method
	 * @name #GetTokenFileCommentV2AuthEgo_apiGET
	 * @param {string} fileId - fileId
	 * @param {string} processInstanceId - processInstanceId
	 */
	public async GetTokenFileCommentV2AuthEgo_apiGET(params: {
		query?: {
			fileId?: string
			processInstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/file/getToken'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['fileId'] !== undefined) {
			queryParameters['fileId'] = params.query['fileId']
		}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 获取文件预览地址
	 * @method
	 * @name #PreviewPathFileCommentV2AuthEgo_apiGET
	 * @param {string} fileId - fileId
	 * @param {string} fileType - fileType
	 * @param {string} processInstanceId - processInstanceId
	 */
	public async PreviewPathFileCommentV2AuthEgo_apiGET(params: {
		query?: {
			fileId?: string
			fileType?: string
			processInstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/file/previewPath'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['fileId'] !== undefined) {
			queryParameters['fileId'] = params.query['fileId']
		}

		if (params.query?.['fileType'] !== undefined) {
			queryParameters['fileType'] = params.query['fileType']
		}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 附件上传接口
	 * @method
	 * @name #UploadFileCommentV2AuthEgo_apiPOST
	 * @param {array} file - file
	 * @param {string} processInstanceId - processInstanceId
	 */
	public async UploadFileCommentV2AuthEgo_apiPOST(params: {
		query?: {
			processInstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse$List$FileInfo$$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/file/upload'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		const result: typing.delegate.ApiResponse$List$FileInfo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 端获取评论列表
	 * @method
	 * @name #ListCommentV2AuthEgo_apiPOST
	 * @param {} commentReq - commentReq
	 */
	public async ListCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 添加回复
	 * @method
	 * @name #AddReplyCommentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async AddReplyCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$SaveCommentReplyVo$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/reply/add'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SaveCommentReplyVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除评论回复
	 * @method
	 * @name #DeleteReplyCommentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteReplyCommentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/auth/v2/comment/reply/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 检查用户A能否替换给用户B
	 * @method
	 * @name #CheckUserAToUserBCardEmployeeV2AuthEgo_apiPOST
	 * @param {} assigneeReplaceDto - assigneeReplaceDto
	 */
	public async CheckUserAToUserBCardEmployeeV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.AssigneeReplaceDto
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/employee/card/checkUserAToUserB'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取员工信息
	 * @method
	 * @name #GetCardEmployeeV2AuthEgo_apiPOST
	 * @param {} employeeQuery - employeeQuery
	 */
	public async GetCardEmployeeV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.EmployeeQuery
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/employee/card/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程预测
	 * @method
	 * @name #GetForecastV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetForecastV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.FlowForecastReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/forecast/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 知会去重接口
	 * @method
	 * @name #CheckRepeatNoticeV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async CheckRepeatNoticeV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CheckNoticeUserReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/notice/checkRepeat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 知会列表
	 * @method
	 * @name #ListRecordNoticeV2AuthEgo_apiPOST
	 * @param {} taskRecordRequest - taskRecordRequest
	 */
	public async ListRecordNoticeV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRecordRequest
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/notice/record/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发送知会
	 * @method
	 * @name #SendNoticeV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async SendNoticeV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.SendNoticeReq
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/auth/v2/notice/send'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取用户社交套件的权限
	 * @method
	 * @name #GetComponentPermissionV2AuthEgo_apiPOST
	 * @param {} permissionVo - permissionVo
	 */
	public async GetComponentPermissionV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.PermissionReq
	}): Promise<typing.delegate.ApiResponse$SocialComponentVo$> {
		let path = ''
		path = '/ego_api/auth/v2/permission/component/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SocialComponentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminPermissionV2AuthEgo_apiPOST
	 * @param {} subTaskDto - subTaskDto
	 */
	public async GrantAuthToAdminPermissionV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.SubTaskDto
	}): Promise<typing.delegate.TaskInfoResultVo> {
		let path = ''
		path = '/ego_api/auth/v2/permission/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskInfoResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 判断用户是否为流程干系人
	 * @method
	 * @name #HasPermissionV2AuthEgo_apiPOST
	 * @param {} reqPermissionVo - reqPermissionVo
	 */
	public async HasPermissionV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.PermissionReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/permission/has'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询流程提醒
	 * @method
	 * @name #GetRemindV2AuthEgo_apiPOST
	 * @param {} remind - remind
	 */
	public async GetRemindV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessRemindPo
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/remind/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置或更新提醒
	 * @method
	 * @name #SaveOrUpdateRemindV2AuthEgo_apiPOST
	 * @param {} remind - remind
	 */
	public async SaveOrUpdateRemindV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessRemindPo
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/remind/saveOrUpdate'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取任务按钮
	 * @method
	 * @name #GetButtonTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取按钮
	 * @method
	 * @name #GetCommandPolicyTypeButtonTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetCommandPolicyTypeButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.CommandPolicyTypeReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/getCommandPolicyType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通过用户名称中英文、邮箱查询用户信息
	 * @method
	 * @name #QueryUserButtonTaskV2AuthEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async QueryUserButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonUserReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/queryUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可撤回节点
	 * @method
	 * @name #TasksRevokeButtonTaskV2AuthEgo_apiPOST
	 * @param {} json - json
	 */
	public async TasksRevokeButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/revoke/tasks'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可退回节点
	 * @method
	 * @name #NodesRollbackButtonTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async NodesRollbackButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/rollback/nodes'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可退回任务
	 * @method
	 * @name #TasksRollbackButtonTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async TasksRollbackButtonTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/button/rollback/tasks'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据文件id删除文件
	 * @method
	 * @name #DeleteFileTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteFileTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 附件的下载
	 * @method
	 * @name #DownloadFileTaskV2AuthEgo_apiGET
	 * @param {string} fileId - fileId
	 * @param {string} processInstanceId - processInstanceId
	 * @param {string} token - token
	 */
	public async DownloadFileTaskV2AuthEgo_apiGET(params: {
		query?: {
			fileId?: string
			processInstanceId?: string
			token?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/download'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['fileId'] !== undefined) {
			queryParameters['fileId'] = params.query['fileId']
		}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		if (params.query?.['token'] !== undefined) {
			queryParameters['token'] = params.query['token']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 生成文件下载token
	 * @method
	 * @name #GetTokenFileTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetTokenFileTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/getToken'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id获取上传附件列表
	 * @method
	 * @name #ListFileTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async ListFileTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取文件预览地址
	 * @method
	 * @name #PreviewPathFileTaskV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async PreviewPathFileTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/previewPath'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 附件上传接口
	 * @method
	 * @name #UploadFileTaskV2AuthEgo_apiPOST
	 * @param {array} file - file
	 * @param {string} taskInstanceId - taskInstanceId
	 */
	public async UploadFileTaskV2AuthEgo_apiPOST(params: {
		query?: {
			taskInstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/task/file/upload'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['taskInstanceId'] !== undefined) {
			queryParameters['taskInstanceId'] = params.query['taskInstanceId']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据taskId查询流程实例Id
	 * @method
	 * @name #GetProcessInstanceIdTaskV2AuthEgo_apiPOST
	 * @param {} taskButtonReq - taskButtonReq
	 */
	public async GetProcessInstanceIdTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/auth/v2/task/getProcessInstanceId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 流程审批历史
	 * @method
	 * @name #ListRecordTaskV2AuthEgo_apiPOST
	 * @param {} taskRecordRequest - taskRecordRequest
	 */
	public async ListRecordTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRecordRequest
	}): Promise<typing.delegate.ApiResponse$TaskProcessListVo$> {
		let path = ''
		path = '/ego_api/auth/v2/task/record/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskProcessListVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 子任务审批历史
	 * @method
	 * @name #SubProInstPageRecordTaskV2AuthEgo_apiPOST
	 * @param {} subProInstRequest - subProInstRequest
	 */
	public async SubProInstPageRecordTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.SubProInstRequest
	}): Promise<typing.delegate.PageResult$SubProInstDto$> {
		let path = ''
		path = '/ego_api/auth/v2/task/record/subProInstPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$SubProInstDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 审批历史与流程预览合并接口
	 * @method
	 * @name #TaskAndForecastRecordTaskV2AuthEgo_apiPOST
	 * @param {} taskRecordRequest - taskRecordRequest
	 */
	public async TaskAndForecastRecordTaskV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRecordRequest
	}): Promise<typing.delegate.ApiResponse$List$V2NodeVo$$> {
		let path = ''
		path = '/ego_api/auth/v2/task/record/taskAndForecast'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$V2NodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取到流程所在的待审批人员信息
	 * @method
	 * @name #GetUrgentV2AuthEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetUrgentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.GetUrgentUserReq
	}): Promise<typing.delegate.ApiResponse$UrgentVo$> {
		let path = ''
		path = '/ego_api/auth/v2/urgent/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$UrgentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 催办发消息
	 * @method
	 * @name #SendUrgentV2AuthEgo_apiPOST
	 * @param {} urgentRequestVo - urgentRequestVo
	 */
	public async SendUrgentV2AuthEgo_apiPOST(params: {
		payload?: typing.delegate.SendUrgentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/auth/v2/urgent/send'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 流程审批历史
	 * @method
	 * @name #ListRecordTaskV3AuthEgo_apiPOST
	 * @param {} taskRecordRequest - taskRecordRequest
	 */
	public async ListRecordTaskV3AuthEgo_apiPOST(params: {
		payload?: typing.delegate.TaskRecordRequest
	}): Promise<typing.delegate.ApiResponse$List$V2NodeVo$$> {
		let path = ''
		path = '/ego_api/auth/v3/task/record/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$V2NodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 加群
	 * @method
	 * @name #AddChatChatV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async AddChatChatV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.AddChatReq
	}): Promise<typing.delegate.ApiResponse$ChatInfoVo$> {
		let path = ''
		path = '/ego_api/client/v1/chat/addChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatInfoVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 创建群
	 * @method
	 * @name #CreateChatChatV1ClientEgo_apiPOST
	 * @param {} clientChatVo - clientChatVo
	 */
	public async CreateChatChatV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CreateChatReq
	}): Promise<typing.delegate.ApiResponse$ChatInfoVo$> {
		let path = ''
		path = '/ego_api/client/v1/chat/createChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatInfoVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取群相关信息
	 * @method
	 * @name #GetChatInfoChatV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetChatInfoChatV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$ChatMessageVo$> {
		let path = ''
		path = '/ego_api/client/v1/chat/getChatInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatMessageVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取群名称以及群描述
	 * @method
	 * @name #GetChatNameChatV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetChatNameChatV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$ChatNameVo$> {
		let path = ''
		path = '/ego_api/client/v1/chat/getChatName'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ChatNameVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取加群干系人列表
	 * @method
	 * @name #GetChatPremissionChatV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetChatPremissionChatV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.GetChatReq
	}): Promise<typing.delegate.ApiResponse$List$ChatPermissionVo$$> {
		let path = ''
		path = '/ego_api/client/v1/chat/getChatPremission'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$List$ChatPermissionVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 手动计算超时
	 * @method
	 * @name #CalculateJobCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async CalculateJobCommonV1ClientEgo_apiPOST(params: {
		payload?: string
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/client/v1/common/calculateJob'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 检查是否显示逐条队列组件(上一条、下一条)
	 * @method
	 * @name #CheckNextApproveCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async CheckNextApproveCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CheckApproveQueueReq
	}): Promise<typing.delegate.ApiResponse$ApproveQueueResult$> {
		let path = ''
		path = '/ego_api/client/v1/common/checkNextApprove'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ApproveQueueResult$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 知会提升去重接口
	 * @method
	 * @name #CheckNoticeUserCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async CheckNoticeUserCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CheckNoticeUserReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/checkNoticeUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除评论
	 * @method
	 * @name #DeleteCommentCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteCommentCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/deleteComment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据文件id删除文件
	 * @method
	 * @name #DeleteFileCommonV1ClientEgo_apiPOST
	 * @param {} reqMap - reqMap
	 */
	public async DeleteFileCommonV1ClientEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/deleteFile'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除回复评论
	 * @method
	 * @name #DeleteReplyCommonV1ClientEgo_apiPOST
	 * @param {} clientCoummentVo - clientCoummentVo
	 */
	public async DeleteReplyCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/deleteReply'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * downloadFile
	 * @method
	 * @name #DownloadFileCommonV1ClientEgo_apiGET
	 * @param {string} commentFileId - commentFileId
	 * @param {string} downloadToken - downloadToken
	 * @param {string} processinstanceId - processinstanceId
	 */
	public async DownloadFileCommonV1ClientEgo_apiGET(params: {
		query?: {
			commentFileId?: string
			downloadToken?: string
			processinstanceId?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_api/client/v1/common/downloadFile'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['commentFileId'] !== undefined) {
			queryParameters['commentFileId'] = params.query['commentFileId']
		}

		if (params.query?.['downloadToken'] !== undefined) {
			queryParameters['downloadToken'] = params.query['downloadToken']
		}

		if (params.query?.['processinstanceId'] !== undefined) {
			queryParameters['processinstanceId'] = params.query['processinstanceId']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取按钮
	 * @method
	 * @name #GetCommandPolicyTypeCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetCommandPolicyTypeCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommandPolicyTypeReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getCommandPolicyType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 移动端获取评论数
	 * @method
	 * @name #GetCommentCountCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetCommentCountCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/client/v1/common/getCommentCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取文件预览地址
	 * @method
	 * @name #GetFileViewPathCommonV1ClientEgo_apiGET
	 * @param {string} commentFileId - commentFileId
	 * @param {string} commentFileType - commentFileType
	 * @param {string} processinstanceId - processinstanceId
	 */
	public async GetFileViewPathCommonV1ClientEgo_apiGET(params: {
		query?: {
			commentFileId?: string
			commentFileType?: string
			processinstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getFileViewPath'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['commentFileId'] !== undefined) {
			queryParameters['commentFileId'] = params.query['commentFileId']
		}

		if (params.query?.['commentFileType'] !== undefined) {
			queryParameters['commentFileType'] = params.query['commentFileType']
		}

		if (params.query?.['processinstanceId'] !== undefined) {
			queryParameters['processinstanceId'] = params.query['processinstanceId']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程预测
	 * @method
	 * @name #GetFlowVirtualInfoForecastCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetFlowVirtualInfoForecastCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.FlowForecastReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getFlowVirtualInfoForecast'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询上一条/下一条待办链接
	 * @method
	 * @name #GetNextApproveUrlCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetNextApproveUrlCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.GetApproveQueueReq
	}): Promise<typing.delegate.ApiResponse$ApproveQueueResult$> {
		let path = ''
		path = '/ego_api/client/v1/common/getNextApproveUrl'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$ApproveQueueResult$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程图SVG
	 * @method
	 * @name #GetProcessSvgCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async GetProcessSvgCommonV1ClientEgo_apiPOST(params: {
		payload?: string
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/client/v1/common/getProcessSvg'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例ID获取已读未读信息
	 * @method
	 * @name #GetReadInfoCommonV1ClientEgo_apiPOST
	 * @param {} jsonMap - jsonMap
	 */
	public async GetReadInfoCommonV1ClientEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getReadInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可撤回节点
	 * @method
	 * @name #GetRevokeScreeningTaskCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async GetRevokeScreeningTaskCommonV1ClientEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getRevokeScreeningTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可退回节点
	 * @method
	 * @name #GetRollBackNodeListCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetRollBackNodeListCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getRollBackNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取可退回任务
	 * @method
	 * @name #GetRollBackScreeningTaskCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetRollBackScreeningTaskCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getRollBackScreeningTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取任务按钮
	 * @method
	 * @name #GetTaskBtnCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetTaskBtnCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getTaskBtn'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 流程处理过程
	 * @method
	 * @name #GetTaskProcessCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async GetTaskProcessCommonV1ClientEgo_apiPOST(params: {
		payload?: string
	}): Promise<typing.delegate.ApiResponse$TaskProcessListVo$> {
		let path = ''
		path = '/ego_api/client/v1/common/getTaskProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$TaskProcessListVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 生成文件下载token
	 * @method
	 * @name #GetTokenCommonV1ClientEgo_apiGET
	 * @param {string} commentFileId - commentFileId
	 * @param {string} processinstanceId - processinstanceId
	 */
	public async GetTokenCommonV1ClientEgo_apiGET(params: {
		query?: {
			commentFileId?: string
			processinstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getToken'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['commentFileId'] !== undefined) {
			queryParameters['commentFileId'] = params.query['commentFileId']
		}

		if (params.query?.['processinstanceId'] !== undefined) {
			queryParameters['processinstanceId'] = params.query['processinstanceId']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通过用户名称中英文、邮箱查询用户信息
	 * @method
	 * @name #GetUserByQueryKeyCommonV1ClientEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetUserByQueryKeyCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonUserReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/getUserByQueryKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询流程提醒
	 * @method
	 * @name #QueryRemindCommonV1ClientEgo_apiPOST
	 * @param {} remind - remind
	 */
	public async QueryRemindCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessRemindPo
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/queryRemind'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 添加评论
	 * @method
	 * @name #SaveCommentCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async SaveCommentCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse$SaveCommentVo$> {
		let path = ''
		path = '/ego_api/client/v1/common/saveComment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SaveCommentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 设置或更新提醒
	 * @method
	 * @name #SaveOrUpdateRemindCommonV1ClientEgo_apiPOST
	 * @param {} remind - remind
	 */
	public async SaveOrUpdateRemindCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessRemindPo
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/saveOrUpdateRemind'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 添加回复
	 * @method
	 * @name #SaveReplyCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async SaveReplyCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/saveReply'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * pc端获取评论列表
	 * @method
	 * @name #SelectCommentListCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectCommentListCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/selectCommentList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 移动端获取评论列表
	 * @method
	 * @name #SelectCommentListAndReplyCountCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectCommentListAndReplyCountCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/selectCommentListAndReplyCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 移动端获取回复列表
	 * @method
	 * @name #SelectReplyListCommonV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectReplyListCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.CommentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/selectReplyList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发送知会
	 * @method
	 * @name #SendRepeatNoticeCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async SendRepeatNoticeCommonV1ClientEgo_apiPOST(params: {
		payload?: string
	}): Promise<typing.delegate.ApiResponse$int$> {
		let path = ''
		path = '/ego_api/client/v1/common/sendRepeatNotice'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置知会为未读
	 * @method
	 * @name #SetTaskNoticeNotReadCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async SetTaskNoticeNotReadCommonV1ClientEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/setTaskNoticeNotRead'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置知会为已读
	 * @method
	 * @name #SetTaskNoticeReadCommonV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async SetTaskNoticeReadCommonV1ClientEgo_apiPOST(params: {
		payload?: {}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/setTaskNoticeRead'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 子任务审批历史
	 * @method
	 * @name #SubProInstPageCommonV1ClientEgo_apiPOST
	 * @param {} subProInstRequest - subProInstRequest
	 */
	public async SubProInstPageCommonV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.SubProInstRequest
	}): Promise<typing.delegate.PageResult$SubProInstDto$> {
		let path = ''
		path = '/ego_api/client/v1/common/subProInstPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$SubProInstDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 附件上传接口
	 * @method
	 * @name #UploadCommonV1ClientEgo_apiPOST
	 * @param {array} file - file
	 * @param {string} processinstanceId - processinstanceId
	 */
	public async UploadCommonV1ClientEgo_apiPOST(params: {
		query?: {
			processinstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/common/upload'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processinstanceId'] !== undefined) {
			queryParameters['processinstanceId'] = params.query['processinstanceId']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminPermissionV1ClientEgo_apiPOST
	 * @param {} subTaskDto - subTaskDto
	 */
	public async GrantAuthToAdminPermissionV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.SubTaskDto
	}): Promise<typing.delegate.TaskInfoResultVo> {
		let path = ''
		path = '/ego_api/client/v1/permission/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskInfoResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * client判断用户是否为流程干系人
	 * @method
	 * @name #HasPermissionPermissionV1ClientEgo_apiPOST
	 * @param {} reqPermissionVo - reqPermissionVo
	 */
	public async HasPermissionPermissionV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.PermissionReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/permission/hasPermission'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * client判断用户社交套件的权限
	 * @method
	 * @name #HasPermissionSocialV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async HasPermissionSocialV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.PermissionReq
	}): Promise<typing.delegate.ApiResponse$SocialComponentVo$> {
		let path = ''
		path = '/ego_api/client/v1/social/hasPermission'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$SocialComponentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据taskId查询流程实例Id
	 * @method
	 * @name #GetProcessInstanceIdTaskV1ClientEgo_apiPOST
	 * @param {} taskButtonReq - taskButtonReq
	 */
	public async GetProcessInstanceIdTaskV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskButtonReq
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/client/v1/task/getProcessInstanceId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据文件id删除文件
	 * @method
	 * @name #DeleteFileTaskfileV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async DeleteFileTaskfileV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/deleteFile'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 附件的下载
	 * @method
	 * @name #DownloadFileTaskfileV1ClientEgo_apiGET
	 * @param {string} downloadToken - downloadToken
	 * @param {string} fileId - fileId
	 * @param {string} processinstanceId - processinstanceId
	 */
	public async DownloadFileTaskfileV1ClientEgo_apiGET(params: {
		query?: {
			downloadToken?: string
			fileId?: string
			processinstanceId?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/downloadFile'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['downloadToken'] !== undefined) {
			queryParameters['downloadToken'] = params.query['downloadToken']
		}

		if (params.query?.['fileId'] !== undefined) {
			queryParameters['fileId'] = params.query['fileId']
		}

		if (params.query?.['processinstanceId'] !== undefined) {
			queryParameters['processinstanceId'] = params.query['processinstanceId']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取文件预览地址
	 * @method
	 * @name #GetFileViewPathTaskfileV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetFileViewPathTaskfileV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/getFileViewPath'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id获取上传附件列表
	 * @method
	 * @name #GetTaskFileListTaskfileV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetTaskFileListTaskfileV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/getTaskFileList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 生成文件下载token
	 * @method
	 * @name #GetTokenTaskfileV1ClientEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetTokenTaskfileV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.TaskFileReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/getToken'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 附件上传接口
	 * @method
	 * @name #UploadTaskfileV1ClientEgo_apiPOST
	 * @param {array} file - file
	 * @param {string} taskInstanceId - taskInstanceId
	 */
	public async UploadTaskfileV1ClientEgo_apiPOST(params: {
		query?: {
			taskInstanceId?: string
		}
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/taskfile/upload'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['taskInstanceId'] !== undefined) {
			queryParameters['taskInstanceId'] = params.query['taskInstanceId']
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 催办发消息
	 * @method
	 * @name #CreateChatUrgentV1ClientEgo_apiPOST
	 * @param {} urgentRequestVo - urgentRequestVo
	 */
	public async CreateChatUrgentV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.SendUrgentReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/urgent/createChat'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取到流程所在的待审批人员信息
	 * @method
	 * @name #GetUrgentTodoInfoUrgentV1ClientEgo_apiPOST
	 * @param {} json - json
	 */
	public async GetUrgentTodoInfoUrgentV1ClientEgo_apiPOST(params: {
		payload?: string
	}): Promise<typing.delegate.ApiResponse$UrgentVo$> {
		let path = ''
		path = '/ego_api/client/v1/urgent/getUrgentTodoInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$UrgentVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取员工信息
	 * @method
	 * @name #GetInfoByEmpIdUserV1ClientEgo_apiPOST
	 * @param {} employeeQuery - employeeQuery
	 */
	public async GetInfoByEmpIdUserV1ClientEgo_apiPOST(params: {
		payload?: typing.delegate.EmployeeQuery
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/client/v1/user/getInfoByEmpId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * healthCheck
	 * @method
	 * @name #CheckHealthEgo_apiGET
	 */
	public async CheckHealthEgo_apiGET(params?: {}): Promise<string> {
		let path = ''
		path = '/ego_api/health/check'
		let body: any
		const queryParameters: any = {}

		const result: string = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 待办查询
	 * @method
	 * @name #PageTodoTaskV2PecEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async PageTodoTaskV2PecEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<typing.delegate.PageResult$TaskBeanDto$> {
		let path = ''
		path = '/ego_api/pec/v2/task/todo/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskBeanDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 我的申请数量
	 * @method
	 * @name #CountApplicationTaskV2PrivateEgo_apiPOST
	 * @param {} queryRequest - queryRequest
	 */
	public async CountApplicationTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.MyApplicationQuery
	}): Promise<typing.delegate.PlainResult$MyApplicationCountBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/application/count'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MyApplicationCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理待办任务列表
	 * @method
	 * @name #ListApplicationTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async ListApplicationTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$MyApplicationQuery$
	}): Promise<typing.delegate.PageResult$MyApplicationBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/application/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$MyApplicationBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办任务数量
	 * @method
	 * @name #CountDoneTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountDoneTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$V2DonePageVo$
	}): Promise<typing.delegate.PlainResult$int$> {
		let path = ''
		path = '/ego_api/private/v2/task/done/count'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$int$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 已办任务列表
	 * @method
	 * @name #ListDoneTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async ListDoneTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$V2DonePageVo$
	}): Promise<typing.delegate.PageResult$TaskBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/done/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskBo$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义分组
	 * @method
	 * @name #ProcessGroupCountTaskV2PrivateEgo_apiPOST
	 * @param {} processCountQuery - processCountQuery
	 */
	public async ProcessGroupCountTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessGroupCountQuery
	}): Promise<typing.delegate.ListResult$TaskCountGroupBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/processGroupCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$TaskCountGroupBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理待办任务数量
	 * @method
	 * @name #CountAgentTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountAgentTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$AgentTaskQuery$
	}): Promise<typing.delegate.PlainResult$PageResponse$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/agent/count'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$PageResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理待办任务数量
	 * @method
	 * @name #CountAgentAgentTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountAgentAgentTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$AgentTaskQuery$
	}): Promise<typing.delegate.ListResult$AgentTaskCountBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/agent/countAgent'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$AgentTaskCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理待办任务数量
	 * @method
	 * @name #CountByTypeAgentTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountByTypeAgentTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$AgentTaskQuery$
	}): Promise<typing.delegate.ListResult$TaskCountGroupBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/agent/countByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$TaskCountGroupBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理待办任务列表
	 * @method
	 * @name #ListAgentTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async ListAgentTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$AgentTaskQuery$
	}): Promise<typing.delegate.PageResult$TaskBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/agent/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskBo$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 待办任务数量
	 * @method
	 * @name #CountTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$RequestPageVo$
	}): Promise<typing.delegate.PlainResult$PageResponse$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/count'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$PageResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 预计待办任务数量
	 * @method
	 * @name #CountExpectTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async CountExpectTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$RequestPageVo$
	}): Promise<typing.delegate.PlainResult$PageResponse$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/expect/count'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$PageResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 预计待办任务列表
	 * @method
	 * @name #ListExpectTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async ListExpectTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$RequestPageVo$
	}): Promise<typing.delegate.PageResult$TaskBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/expect/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskBo$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 待办任务列表
	 * @method
	 * @name #ListTodoTaskV2PrivateEgo_apiPOST
	 * @param {} queryPageRequest - queryPageRequest
	 */
	public async ListTodoTaskV2PrivateEgo_apiPOST(params: {
		payload?: typing.delegate.PageRequest$RequestPageVo$
	}): Promise<typing.delegate.PageResult$TaskBo$> {
		let path = ''
		path = '/ego_api/private/v2/task/todo/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskBo$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 添加委托授权
	 * @method
	 * @name #AddAgentV1SpEgo_apiPOST
	 * @param {} fixFlowAgentInfoVo - fixFlowAgentInfoVo
	 */
	public async AddAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.FixFlowAgentInfoVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/agent/add'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除委托信息
	 * @method
	 * @name #DeleteAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async DeleteAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/agent/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托列表详情
	 * @method
	 * @name #GetAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async GetAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<Array<typing.delegate.FixflowAgentVo>> {
		let path = ''
		path = '/ego_api/sp/v1/agent/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowAgentVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 委托授权历史记录详情
	 * @method
	 * @name #GetHisAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async GetHisAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<typing.delegate.AgentResponeVo> {
		let path = ''
		path = '/ego_api/sp/v1/agent/getHis'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.AgentResponeVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程列表
	 * @method
	 * @name #GetProcessListAgentV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GetProcessListAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentProcessReqParam
	}): Promise<Array<typing.delegate.FixFlowProcessInfoVo>> {
		let path = ''
		path = '/ego_api/sp/v1/agent/getProcessList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixFlowProcessInfoVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 委托授权列表
	 * @method
	 * @name #ListAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async ListAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<Array<typing.delegate.FixflowAgentVo>> {
		let path = ''
		path = '/ego_api/sp/v1/agent/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowAgentVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 委托授权历史记录
	 * @method
	 * @name #ListHisAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async ListHisAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<typing.delegate.AgentResponeVo> {
		let path = ''
		path = '/ego_api/sp/v1/agent/listHis'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.AgentResponeVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托授权历史记录
	 * @method
	 * @name #ListHistoryAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async ListHistoryAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<typing.delegate.AgentResponeVo> {
		let path = ''
		path = '/ego_api/sp/v1/agent/listHistory'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.AgentResponeVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托列表
	 * @method
	 * @name #QueryAgentAgentV1SpEgo_apiPOST
	 * @param {} agentVo - agentVo
	 */
	public async QueryAgentAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.AgentReqParam
	}): Promise<Array<typing.delegate.FixflowAgentVo>> {
		let path = ''
		path = '/ego_api/sp/v1/agent/queryAgent'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowAgentVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询委托历史
	 * @method
	 * @name #SelAgentByHisAgentV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SelAgentByHisAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/agent/selAgentByHis'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 修改委托授权
	 * @method
	 * @name #UpdateAgentV1SpEgo_apiPOST
	 * @param {} fixFlowAgentInfoVo - fixFlowAgentInfoVo
	 */
	public async UpdateAgentV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.FixFlowAgentInfoVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/agent/update'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除用户缓存
	 * @method
	 * @name #DelTenantUserCacheApprovalV1SpEgo_apiPOST
	 * @param {array} empList -
	 * @param {string} tenantId -
	 */
	public async DelTenantUserCacheApprovalV1SpEgo_apiPOST(params: {
		query?: {
			empList?: Array<string>
			tenantId?: string
		}
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/approval/delTenantUserCache'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['empList'] !== undefined) {
			queryParameters['empList'] = params.query['empList']
		}

		if (params.query?.['tenantId'] !== undefined) {
			queryParameters['tenantId'] = params.query['tenantId']
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id,或者任务id,获取流程详细信息
	 * @method
	 * @name #GetIMApprovalDetailApprovalV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetIMApprovalDetailApprovalV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ApprovalProcessQueryReq
	}): Promise<typing.delegate.ApprovalDetailVo> {
		let path = ''
		path = '/ego_api/sp/v1/approval/getIMApprovalDetail'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApprovalDetailVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * API获取auth接口
	 * @method
	 * @name #GetAuthV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetAuthV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.GetAuthReq
	}): Promise<typing.delegate.CacheUserBean> {
		let path = ''
		path = '/ego_api/sp/v1/auth/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.CacheUserBean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 代理批量同意执行
	 * @method
	 * @name #RunBatchAgentFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async RunBatchAgentFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.BatchRunProcessReqParam
	}): Promise<Array<typing.delegate.ExecuteLog>> {
		let path = ''
		path = '/ego_api/sp/v1/flow/agent/batch/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ExecuteLog> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 批量同意执行
	 * @method
	 * @name #OneRunAgentFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async OneRunAgentFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<typing.delegate.ExecuteLog> {
		let path = ''
		path = '/ego_api/sp/v1/flow/agent/oneRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ExecuteLog = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 批量同意执行
	 * @method
	 * @name #RunBatchFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async RunBatchFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<Array<typing.delegate.ExecuteLog>> {
		let path = ''
		path = '/ego_api/sp/v1/flow/batch/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ExecuteLog> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除流程实例数据(不触发流程结束/终止事件)
	 * @method
	 * @name #DeleteProcessInstanceFlowV1SpEgo_apiPOST
	 * @param {} taskVo - taskVo
	 */
	public async DeleteProcessInstanceFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunReceiveTaskReq
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/flow/deleteProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 审批流程时,获取下个节点的审批人范围
	 * @method
	 * @name #FindNextNodeUserByGeneralFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async FindNextNodeUserByGeneralFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<Array<typing.delegate.OptionalNodeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/flow/findNextNodeUserByGeneral'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.OptionalNodeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 提交流程时,获取下个节点的审批人范围
	 * @method
	 * @name #FindNextNodeUserBySubmitFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async FindNextNodeUserBySubmitFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.StartProcessReqParam
	}): Promise<Array<typing.delegate.OptionalNodeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/flow/findNextNodeUserBySubmit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.OptionalNodeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 批量同意执行
	 * @method
	 * @name #OneRunFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async OneRunFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<typing.delegate.ExecuteLog> {
		let path = ''
		path = '/ego_api/sp/v1/flow/oneRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ExecuteLog = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通用执行(同意、终止、追回、转办、退回指定步骤、暂存待办、保存草稿、加签、指定任务退回、代理执行)
	 * @method
	 * @name #RunFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async RunFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/flow/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 驱动等待节点
	 * @method
	 * @name #RunReceiveTaskFlowV1SpEgo_apiPOST
	 * @param {} taskVo - taskVo
	 */
	public async RunReceiveTaskFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunReceiveTaskReq
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/flow/runReceiveTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通用执行(同意、终止、撤回、转办、拒绝、暂存、加签、代理执行)
	 * @method
	 * @name #RunResultFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async RunResultFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunProcessReqParam
	}): Promise<typing.delegate.PlainResult$RunProcessResultVo$> {
		let path = ''
		path = '/ego_api/sp/v1/flow/runResult'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$RunProcessResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程分类
	 * @method
	 * @name #SelectFlowTypeFlowV1SpEgo_apiPOST
	 * @param {} param - param
	 */
	public async SelectFlowTypeFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessTypeParam
	}): Promise<Array<typing.delegate.ProcessTypeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/flow/selectFlowType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ProcessTypeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 启动并提交接口
	 * @method
	 * @name #StartFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async StartFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.StartProcessReqParam
	}): Promise<typing.delegate.StartProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/flow/start'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.StartProcessResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 启动后不自动提交,停留在提交节点
	 * @method
	 * @name #StartNotAutoSubmitFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async StartNotAutoSubmitFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.StartProcessReqParam
	}): Promise<typing.delegate.StartProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/flow/startNotAutoSubmit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.StartProcessResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 测试产生tmp文件的原因
	 * @method
	 * @name #TestTmpLogFlowV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async TestTmpLogFlowV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.StartProcessReqParam
	}): Promise<typing.delegate.StartProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/flow/testTmpLog'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.StartProcessResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除没有流程实例的processkey
	 * @method
	 * @name #DeleteProcessInstanceByProcessKeyManagerV1SpEgo_apiPOST
	 * @param {} processReqParam - processReqParam
	 */
	public async DeleteProcessInstanceByProcessKeyManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessReqParam
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/manager/deleteProcessInstanceByProcessKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 历史任务交接转办
	 * @method
	 * @name #DoneListByIdManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async DoneListByIdManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerBatchTransferRequestVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/doneListById'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 历史任务交接转办
	 * @method
	 * @name #DoneTransferManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async DoneTransferManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerBatchTransferRequestVo
	}): Promise<typing.delegate.ExecuteLog> {
		let path = ''
		path = '/ego_api/sp/v1/manager/doneTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ExecuteLog = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-重新计算流程预览
	 * @method
	 * @name #ForecastRunManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ForecastRunManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRunProcessRequestVo
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/forecastRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-获取节点列表
	 * @method
	 * @name #GetAllNodeListManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetAllNodeListManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessEndFlowReqParam
	}): Promise<Array<typing.delegate.ActivitNodeVo>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/getAllNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ActivitNodeVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-查询可退回指定历史节点列表
	 * @method
	 * @name #GetRollbackHistoryNodeListManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async GetRollbackHistoryNodeListManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRollBackRequestVo
	}): Promise<Array<typing.delegate.ActivitNodeVo>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/getRollbackHistoryNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ActivitNodeVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-任意流转
	 * @method
	 * @name #ManagerArbitrarilyProcessManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ManagerArbitrarilyProcessManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRunProcessRequestVo
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerArbitrarilyProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作批量终止
	 * @method
	 * @name #ManagerBatchEndFlowProcessManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ManagerBatchEndFlowProcessManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerBatchEndReqParam
	}): Promise<Array<typing.delegate.ExecuteLog>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerBatchEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ExecuteLog> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理执行(终止)
	 * @method
	 * @name #ManagerEndFlowProcessManagerV1SpEgo_apiPOST
	 * @param {} param - param
	 */
	public async ManagerEndFlowProcessManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessEndFlowReqParam
	}): Promise<typing.delegate.ManagerFlowEndResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ManagerFlowEndResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作重启
	 * @method
	 * @name #ManagerRestartProcessManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ManagerRestartProcessManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRunProcessRequestVo
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerRestartProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作-退回指定历史节点
	 * @method
	 * @name #ManagerRollbackToHistoryNodeManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ManagerRollbackToHistoryNodeManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRunProcessRequestVo
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerRollbackToHistoryNode'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 管理操作跳过，退回上一步
	 * @method
	 * @name #ManagerRunTaskProcessManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ManagerRunTaskProcessManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerRunProcessRequestVo
	}): Promise<typing.delegate.RunProcessResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/manager/managerRunTaskProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.RunProcessResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询定义流程实例每个版本个数
	 * @method
	 * @name #QueryProcessInstanceNumManagerV1SpEgo_apiPOST
	 * @param {} processReqParam - processReqParam
	 */
	public async QueryProcessInstanceNumManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessReqParam
	}): Promise<Array<typing.delegate.FixflowProcessDesignerVo>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/queryProcessInstanceNum'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowProcessDesignerVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询定义流程版本
	 * @method
	 * @name #QueryProcessVersionManagerV1SpEgo_apiPOST
	 * @param {} processReqParam - processReqParam
	 */
	public async QueryProcessVersionManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessReqParam
	}): Promise<Array<typing.delegate.FixflowDefProcessdefinitionVo>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/queryProcessVersion'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowDefProcessdefinitionVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作批量转发(同步)
	 * @method
	 * @name #SyncBatchTransferManagerV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async SyncBatchTransferManagerV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ManagerBatchTransferRequestVo
	}): Promise<Array<typing.delegate.ExecuteLog>> {
		let path = ''
		path = '/ego_api/sp/v1/manager/syncBatchTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ExecuteLog> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据登录人获取代理知会列表
	 * @method
	 * @name #GetAgentNoticeByUserIdNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetAgentNoticeByUserIdNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getAgentNoticeByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义代理知会数量
	 * @method
	 * @name #GetAgentNoticeCountByTypeNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetAgentNoticeCountByTypeNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getAgentNoticeCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据登录人获取代理未读知会数量
	 * @method
	 * @name #GetAgentNoticeCountByUserIdNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetAgentNoticeCountByUserIdNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getAgentNoticeCountByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据noticeId获取知会详细信息接口
	 * @method
	 * @name #GetNoticeByIdNoticeV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetNoticeByIdNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskNoticeReqParam
	}): Promise<typing.delegate.FlowTaskNoticeInfoResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getNoticeById'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.FlowTaskNoticeInfoResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程定义未读/已读知会数量
	 * @method
	 * @name #GetNoticeCountByTypeNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetNoticeCountByTypeNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getNoticeCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据登录人获取未读/已读知会数量
	 * @method
	 * @name #GetNoticeCountByUserIdNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetNoticeCountByUserIdNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getNoticeCountByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据登录人获取已读(含代理已读知会)/未读知会列表
	 * @method
	 * @name #GetNoticeListPageByUserIdNoticeV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetNoticeListPageByUserIdNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/notice/getNoticeListPageByUserId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置所有未读为已读
	 * @method
	 * @name #ReadAllNoticeV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async ReadAllNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.SetAllNoticeReadReq
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/notice/readAll'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 设置知会为已读
	 * @method
	 * @name #SetTaskNoticeReadNoticeV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async SetTaskNoticeReadNoticeV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskNoticeReqParam
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/notice/setTaskNoticeRead'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发布流程
	 * @method
	 * @name #BatchDeploymentDefProcessV1SpEgo_apiPOST
	 * @param {} requestVo - requestVo
	 */
	public async BatchDeploymentDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessDeploymentReqParam
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/batchDeployment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 手动删除流程定义缓存
	 * @method
	 * @name #DelProcessCacheDefProcessV1SpEgo_apiPOST
	 * @param {} processVo - processVo
	 */
	public async DelProcessCacheDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/delProcessCache'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 删除流程定义及数据
	 * @method
	 * @name #DeleteDeploymentDefProcessV1SpEgo_apiPOST
	 * @param {} processVo - processVo
	 */
	public async DeleteDeploymentDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessDelReqParam
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/deleteDeployment'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取提交节点ID
	 * @method
	 * @name #GetFirstNodeIdDefProcessV1SpEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetFirstNodeIdDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getFirstNodeId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通过流程key获取host
	 * @method
	 * @name #GetHostByProcessKeyDefProcessV1SpEgo_apiPOST
	 * @param {} processVo - processVo
	 */
	public async GetHostByProcessKeyDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessVo
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getHostByProcessKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取节点发送消息的跳转打开方式
	 * @method
	 * @name #GetNodeOpenModeDefProcessV1SpEgo_apiPOST
	 * @param {} requestVo - requestVo
	 */
	public async GetNodeOpenModeDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.CheckSendMessageRequest
	}): Promise<typing.delegate.CheckSendMessageRequest> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getNodeOpenMode'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.CheckSendMessageRequest =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过流程key获取流程的单据类型
	 * @method
	 * @name #GetProcessInfoDefProcessV1SpEgo_apiPOST
	 * @param {} processVo - processVo
	 */
	public async GetProcessInfoDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessVo
	}): Promise<typing.delegate.FixFlowProcessInfoVo> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getProcessInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.FixFlowProcessInfoVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程图SVG
	 * @method
	 * @name #GetProcessSvgDefProcessV1SpEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetProcessSvgDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<{}> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getProcessSvg'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: {} = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据process_definition_key获取最新版本的流程图SVG
	 * @method
	 * @name #GetProcessSvgByDefKeyDefProcessV1SpEgo_apiPOST
	 * @param {} reqBean - reqBean
	 */
	public async GetProcessSvgByDefKeyDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<{}> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/getProcessSvgByDefKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: {} = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询节点的人员设置
	 * @method
	 * @name #SelectNodeStaffListDefProcessV1SpEgo_apiPOST
	 * @param {} requestVo - requestVo
	 */
	public async SelectNodeStaffListDefProcessV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.FixflowRunNodeStaffConfigVo
	}): Promise<Array<typing.delegate.FixflowRunNodeStaffConfigVo>> {
		let path = ''
		path = '/ego_api/sp/v1/process/def/selectNodeStaffList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.FixflowRunNodeStaffConfigVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #FlowTimeoutConsumerDataVariableShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async FlowTimeoutConsumerDataVariableShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/sp/v1/share/dataVariable/FlowTimeoutConsumer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #FlowVirtualConsumerDataVariableShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async FlowVirtualConsumerDataVariableShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/sp/v1/share/dataVariable/FlowVirtualConsumer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #ListDataVariableShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async ListDataVariableShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$MapObject$> {
		let path = ''
		path = '/ego_api/sp/v1/share/dataVariable/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #RemoveCacheDataVariableShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async RemoveCacheDataVariableShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/sp/v1/share/dataVariable/removeCache'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取列表
	 * @method
	 * @name #SendNoticeServiceonMessageDataVariableShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async SendNoticeServiceonMessageDataVariableShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/sp/v1/share/dataVariable/sendNoticeServiceonMessage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询分享链接接口
	 * @method
	 * @name #GetShareV1SpEgo_apiPOST
	 * @param {} shareRequestBean - shareRequestBean
	 */
	public async GetShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ShareResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/share/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ShareResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询流程数据(应用表单分享场景)
	 * @method
	 * @name #GetNonUserShareV1SpEgo_apiPOST
	 * @param {} shareRequestBean - shareRequestBean
	 */
	public async GetNonUserShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ShareResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/share/getNonUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ShareResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminShareV1SpEgo_apiPOST
	 * @param {} requestBean - requestBean
	 */
	public async GrantAuthToAdminShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.TaskInfoResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/share/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskInfoResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * redisGet
	 * @method
	 * @name #RedisGetShareV1SpEgo_apiPOST
	 * @param {} shareReq - shareReq
	 */
	public async RedisGetShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/sp/v1/share/redisGet'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * redisRun
	 * @method
	 * @name #RedisRunShareV1SpEgo_apiPOST
	 * @param {} shareReq - shareReq
	 */
	public async RedisRunShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/sp/v1/share/redisRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #SelectShareProcessInfoShareV1SpEgo_apiPOST
	 * @param {} shareRequestBean - shareRequestBean
	 */
	public async SelectShareProcessInfoShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ShareResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/share/selectShareProcessInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ShareResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * testRunCustom
	 * @method
	 * @name #TestRunCustomShareV1SpEgo_apiPOST
	 * @param {} shareReq - shareReq
	 */
	public async TestRunCustomShareV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ShareReq
	}): Promise<typing.delegate.ApiResponse$string$> {
		let path = ''
		path = '/ego_api/sp/v1/share/testRunCustom'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * getSimulateResult
	 * @method
	 * @name #GetSimulateResultSimulateV1SpEgo_apiPOST
	 * @param {} queryParam - queryParam
	 */
	public async GetSimulateResultSimulateV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.QuerySimulateReqParam
	}): Promise<typing.delegate.SimulateResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/simulate/getSimulateResult'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.SimulateResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 执行流程模拟运行
	 * @method
	 * @name #RunSimulateV1SpEgo_apiPOST
	 * @param {} simulateVo - simulateVo
	 */
	public async RunSimulateV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RunSimulateVo
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/simulate/run'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * terminate
	 * @method
	 * @name #TerminateSimulateV1SpEgo_apiPOST
	 * @param {} queryParam - queryParam
	 */
	public async TerminateSimulateV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.QuerySimulateReqParam
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/simulate/terminate'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义代理已办数量
	 * @method
	 * @name #AgentDoneCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentDoneCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentDoneCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 代理已办查询分页列表
	 * @method
	 * @name #AgentDoneTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentDoneTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentDoneTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 代理已办查询数量
	 * @method
	 * @name #AgentDoneTaskCountTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentDoneTaskCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentDoneTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取代理待办流程和数量
	 * @method
	 * @name #AgentToDoCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentToDoCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentToDoCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 代理待办查询
	 * @method
	 * @name #AgentToDoTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentToDoTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentToDoTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取代理待办委托人和数量
	 * @method
	 * @name #AgentToDoTaskUserTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async AgentToDoTaskUserTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.AgentResultVo>> {
		let path = ''
		path = '/ego_api/sp/v1/task/agentToDoTaskUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.AgentResultVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 竞签任务分页列表
	 * @method
	 * @name #BiddingDoneTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async BiddingDoneTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/biddingDoneTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 竞签任务总数查询
	 * @method
	 * @name #BiddingDoneTaskCountTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async BiddingDoneTaskCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/task/biddingDoneTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 竞签已办任务按流程定义进行分类
	 * @method
	 * @name #BiddingTaskCountByProcessTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async BiddingTaskCountByProcessTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/biddingTaskCountByProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 竞签已办，按审批按钮类型分类
	 * @method
	 * @name #BiddingTaskCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async BiddingTaskCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.DoneTaskCommandTypeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/biddingTaskCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.DoneTaskCommandTypeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办查询分页列表
	 * @method
	 * @name #DoneTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async DoneTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/doneTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 已办查询数量
	 * @method
	 * @name #DoneTaskCountTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async DoneTaskCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/task/doneTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义已办数量
	 * @method
	 * @name #DoneTaskCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async DoneTaskCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/doneTaskCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 预计待办查询
	 * @method
	 * @name #ExpectTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestVo - requestVo
	 */
	public async ExpectTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ExpectTaskReq
	}): Promise<Array<typing.delegate.PortalExpectTaskResultVo>> {
		let path = ''
		path = '/ego_api/sp/v1/task/expectTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.PortalExpectTaskResultVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 预计待办查询数量
	 * @method
	 * @name #ExpectTaskByPageCountTaskV1SpEgo_apiPOST
	 * @param {} requestVo - requestVo
	 */
	public async ExpectTaskByPageCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ExpectTaskReq
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/task/expectTaskByPageCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取人员替换列表
	 * @method
	 * @name #FindUserReplaceTaskV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async FindUserReplaceTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessHistoryPrintRequest
	}): Promise<Array<string>> {
		let path = ''
		path = '/ego_api/sp/v1/task/findUserReplace'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<string> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * API获取auth接口
	 * @method
	 * @name #GetAuthTaskV1SpEgo_apiPOST
	 * @param {} authRequestBean - authRequestBean
	 */
	public async GetAuthTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.GetAuthReq
	}): Promise<typing.delegate.CacheUserBean> {
		let path = ''
		path = '/ego_api/sp/v1/task/getAuth'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.CacheUserBean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取有效执行节点
	 * @method
	 * @name #GetEffectiveTaskTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetEffectiveTaskTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<Array<typing.delegate.EffectiveTaskVo>> {
		let path = ''
		path = '/ego_api/sp/v1/task/getEffectiveTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.EffectiveTaskVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程定义预计待办数量
	 * @method
	 * @name #GetExceptCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetExceptCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ExpectTaskReq
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/getExceptCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 我的申请查询
	 * @method
	 * @name #GetMyApplicationTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetMyApplicationTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.MyApplicationVo>> {
		let path = ''
		path = '/ego_api/sp/v1/task/getMyApplication'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.MyApplicationVo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 我的申请查询数量
	 * @method
	 * @name #GetMyApplicationCountTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetMyApplicationCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/task/getMyApplicationCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义我的申请数量
	 * @method
	 * @name #GetMyApplicationCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async GetMyApplicationCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/getMyApplicationCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据流程实例id获取流程实例信息
	 * @method
	 * @name #GetProcessInstanceTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetProcessInstanceTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<typing.delegate.ProcessInstanceResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/task/getProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ProcessInstanceResultVo =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过任务ID获取任务数据信息
	 * @method
	 * @name #GetRunTaskinstanceTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetRunTaskinstanceTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskInstanceReqParam
	}): Promise<typing.delegate.FixflowRunTaskinstanceDto> {
		let path = ''
		path = '/ego_api/sp/v1/task/getRunTaskinstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.FixflowRunTaskinstanceDto =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取发起节点Id
	 * @method
	 * @name #GetStartElementIdTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetStartElementIdTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.StartProcessResultVo
	}): Promise<string> {
		let path = ''
		path = '/ego_api/sp/v1/task/getStartElementId'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取任务按钮
	 * @method
	 * @name #GetTaskBtnTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetTaskBtnTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskBtnReqParam
	}): Promise<typing.delegate.TaskBtnResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/task/getTaskBtn'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskBtnResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通过任务ID获取流程实例ID和当前任务节点和表单地址
	 * @method
	 * @name #GetTaskInfoTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetTaskInfoTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskInstanceReqParam
	}): Promise<typing.delegate.TaskInfoResultVo> {
		let path = ''
		path = '/ego_api/sp/v1/task/getTaskInfo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskInfoResultVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 通过任务ID获取任务信息
	 * @method
	 * @name #GetTaskInstanceTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetTaskInstanceTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.TaskInstanceReqParam
	}): Promise<typing.delegate.TaskInstanceVo> {
		let path = ''
		path = '/ego_api/sp/v1/task/getTaskInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskInstanceVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 流程处理过程
	 * @method
	 * @name #GetTaskProcessTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async GetTaskProcessTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<typing.delegate.TaskProcessListVo> {
		let path = ''
		path = '/ego_api/sp/v1/task/getTaskProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.TaskProcessListVo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 按按钮类型分组代理已办数据
	 * @method
	 * @name #SelectAgentCommandTypeTaskV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectAgentCommandTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.获取已办任务按钮类型和分组数量的参数对象
	}): Promise<Array<typing.delegate.DoneTaskCommandTypeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/selectAgentCommandType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.DoneTaskCommandTypeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 按按钮类型分组已办数据
	 * @method
	 * @name #SelectCommandTypeTaskV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectCommandTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.获取已办任务按钮类型和分组数量的参数对象
	}): Promise<Array<typing.delegate.DoneTaskCommandTypeDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/selectCommandType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.DoneTaskCommandTypeDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取代理待办流程和数量
	 * @method
	 * @name #SelectProcessHistoryPrintDataTaskV1SpEgo_apiPOST
	 * @param {} req - req
	 */
	public async SelectProcessHistoryPrintDataTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessHistoryPrintRequest
	}): Promise<Array<typing.delegate.ProcessHistoryPrintDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/selectProcessHistoryPrintData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ProcessHistoryPrintDto> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 待办查询
	 * @method
	 * @name #ToDoTaskByPageTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async ToDoTaskByPageTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskBeanDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/toDoTaskByPage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskBeanDto> = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 待办查询数量
	 * @method
	 * @name #ToDoTaskCountTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async ToDoTaskCountTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<number> {
		let path = ''
		path = '/ego_api/sp/v1/task/toDoTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: number = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程定义待办数量
	 * @method
	 * @name #ToDoTaskCountByTypeTaskV1SpEgo_apiPOST
	 * @param {} requestPageVo - requestPageVo
	 */
	public async ToDoTaskCountByTypeTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.RequestPageVo
	}): Promise<Array<typing.delegate.TaskCountDto>> {
		let path = ''
		path = '/ego_api/sp/v1/task/toDoTaskCountByType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.TaskCountDto> = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 更新缓存
	 * @method
	 * @name #UpdateCacheTaskV1SpEgo_apiPOST
	 * @param {} reqParam - reqParam
	 */
	public async UpdateCacheTaskV1SpEgo_apiPOST(params: {
		payload?: typing.delegate.ProcessInstanceReqParam
	}): Promise<boolean> {
		let path = ''
		path = '/ego_api/sp/v1/task/updateCache'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 新增委托授权
	 * @method
	 * @name #AddDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateRequest - delegateRequest
	 */
	public async AddDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateRequest
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/add'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 代理查询委托授权详情
	 * @method
	 * @name #GetAdminDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateQuery - delegateQuery
	 */
	public async GetAdminDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateAdminQuery
	}): Promise<typing.delegate.ApiResponse$DelegateBo$> {
		let path = ''
		path = '/ego_api/v3/private/delegate/admin/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$DelegateBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理查询创建列表
	 * @method
	 * @name #ListAdminDelegatePrivateV3Ego_apiPOST
	 * @param {} delegatePageRequest - delegatePageRequest
	 */
	public async ListAdminDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegatePageRequest
	}): Promise<typing.delegate.PageResult$DelegateBo$> {
		let path = ''
		path = '/ego_api/v3/private/delegate/admin/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$DelegateBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理新增委托授权
	 * @method
	 * @name #AdminAddDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateRequest - delegateRequest
	 */
	public async AdminAddDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateRequest
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/v3/private/delegate/adminAdd'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 代理修改委托授权
	 * @method
	 * @name #AdminEditDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateRequest - delegateRequest
	 */
	public async AdminEditDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateRequest
	}): Promise<typing.delegate.ApiResponse$boolean$> {
		let path = ''
		path = '/ego_api/v3/private/delegate/adminEdit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 删除委托授权
	 * @method
	 * @name #DeleteDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateQuery - delegateQuery
	 */
	public async DeleteDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateQuery
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/delete'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 修改委托授权
	 * @method
	 * @name #EditDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateRequest - delegateRequest
	 */
	public async EditDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateRequest
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/edit'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托授权详情
	 * @method
	 * @name #GetDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateQuery - delegateQuery
	 */
	public async GetDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateQuery
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托授权历史详情
	 * @method
	 * @name #GetHistoryDelegatePrivateV3Ego_apiPOST
	 * @param {} delegateQuery - delegateQuery
	 */
	public async GetHistoryDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.DelegateQuery
	}): Promise<typing.delegate.ApiResponse$DelegateBo$> {
		let path = ''
		path = '/ego_api/v3/private/delegate/history/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse$DelegateBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询委托授权历史列表
	 * @method
	 * @name #ListHistoryDelegatePrivateV3Ego_apiPOST
	 */
	public async ListHistoryDelegatePrivateV3Ego_apiPOST(params?: {}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/history/list'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询委托授权列表
	 * @method
	 * @name #ListDelegatePrivateV3Ego_apiPOST
	 */
	public async ListDelegatePrivateV3Ego_apiPOST(params?: {}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/list'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程列表
	 * @method
	 * @name #ListProcessDelegatePrivateV3Ego_apiPOST
	 * @param {} processSearchRequestDto - processSearchRequestDto
	 */
	public async ListProcessDelegatePrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.ProcessSearchRequestDto
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/delegate/process/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程预测
	 * @method
	 * @name #GetForecastPrivateV3Ego_apiPOST
	 * @param {} req - req
	 */
	public async GetForecastPrivateV3Ego_apiPOST(params: {
		payload?: typing.delegate.FlowForecastReq
	}): Promise<typing.delegate.ApiResponse> {
		let path = ''
		path = '/ego_api/v3/private/forecast/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ApiResponse = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据dashboardid删除当前用户某的自定义面板
	 * @method
	 * @name #DeleteByCurrentUserDashboardPrivateV1ApiEgo_bpaGET
	 * @param {string} dashboardId - dashboard_id
	 */
	public async DeleteByCurrentUserDashboardPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			dashboardId?: string
		}
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dashboard/deleteByCurrentUser'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['dashboardId'] !== undefined) {
			queryParameters['dashboard_id'] = params.query['dashboardId']
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询当前用户的自定义面板
	 * @method
	 * @name #GetByCurrentUserDashboardPrivateV1ApiEgo_bpaGET
	 */
	public async GetByCurrentUserDashboardPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dashboard/getByCurrentUser'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 保存当前用户的自定义面板
	 * @method
	 * @name #SaveOwnerDashboardPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SaveOwnerDashboardPrivateV1ApiEgo_bpaPOST(params: {
		payload?: Array<typing.delegate.CustomPanelBo>
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dashboard/saveOwner'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 根据dashboardid修改当前用户某的自定义面板
	 * @method
	 * @name #UpdateCustomPanelByCurrentUserDashboardPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async UpdateCustomPanelByCurrentUserDashboardPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.CustomPanelBo
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dashboard/updateCustomPanelByCurrentUser'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 搜索部门管理者所管理的部门
	 * @method
	 * @name #GetDeptByNameInCurrentLeaderManagerDeptPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetDeptByNameInCurrentLeaderManagerDeptPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ParamBo
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dept/manager/getDeptByNameInCurrentLeader'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取部门管理者信息
	 * @method
	 * @name #GetDeptLeaderInfoManagerDeptPrivateV1ApiEgo_bpaGET
	 * @param {string} departmentId - department_id
	 */
	public async GetDeptLeaderInfoManagerDeptPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			departmentId?: string
		}
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dept/manager/getDeptLeaderInfo'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['departmentId'] !== undefined) {
			queryParameters['department_id'] = params.query['departmentId']
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 查询根据字母分组排序的流程列表
	 * @method
	 * @name #LetterGroupListManagerDeptPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async LetterGroupListManagerDeptPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessNameParam
	}): Promise<typing.delegate.PlainResult$List$GroupListBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/dept/manager/letterGroupList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$GroupListBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据员工编号或姓名邮箱获取员工信息
	 * @method
	 * @name #SearchEmployeeEmployeePrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async SearchEmployeeEmployeePrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ParamBo
	}): Promise<typing.delegate.PageResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/employee/searchEmployee'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 表单图表-数据钻取
	 * @method
	 * @name #FormViewDepthFormPrivateV1ApiEgo_bpaGET
	 * @param {integer} depthLevel - depthLevel
	 * @param {string} depthName - depthName
	 * @param {integer} id - id
	 * @param {string} kpiObject - kpiObject
	 * @param {string} seriesObject - seriesObject
	 */
	public async FormViewDepthFormPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			depthLevel?: number
			depthName?: string
			id?: number
			kpiObject?: string
			seriesObject?: string
		}
	}): Promise<typing.delegate.PlainResult$object$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/formViewDepth'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['depthLevel'] !== undefined) {
			queryParameters['depthLevel'] = params.query['depthLevel']
		}

		if (params.query?.['depthName'] !== undefined) {
			queryParameters['depthName'] = params.query['depthName']
		}

		if (params.query?.['id'] !== undefined) {
			queryParameters['id'] = params.query['id']
		}

		if (params.query?.['kpiObject'] !== undefined) {
			queryParameters['kpiObject'] = params.query['kpiObject']
		}

		if (params.query?.['seriesObject'] !== undefined) {
			queryParameters['seriesObject'] = params.query['seriesObject']
		}

		const result: typing.delegate.PlainResult$object$ = await this.http.request(
			{
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 查看流程范围
	 * @method
	 * @name #ListProcessScopeFormPrivateV1ApiEgo_bpaPOST
	 */
	public async ListProcessScopeFormPrivateV1ApiEgo_bpaPOST(params?: {}): Promise<typing.delegate.PlainResult$List$ProcessTypeViewResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/listProcessScope'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$List$ProcessTypeViewResp$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 表单列表
	 * @method
	 * @name #PageFormPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async PageFormPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$FormBo$
	}): Promise<typing.delegate.PageResult$FormBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$FormBo$ = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 保存
	 * @method
	 * @name #SaveFormPrivateV1ApiEgo_bpaPOST
	 * @param {} formBo - formBo
	 */
	public async SaveFormPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.FormBo
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/save'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 订阅
	 * @method
	 * @name #SaveSubscribeFormPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaFormSubscribePo - bpaFormSubscribePo
	 */
	public async SaveSubscribeFormPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaFormSubscribePo
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/saveSubscribe'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 更新
	 * @method
	 * @name #UpdateFormFormPrivateV1ApiEgo_bpaPOST
	 * @param {} formBo - formBo
	 */
	public async UpdateFormFormPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.FormBo
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/form/updateForm'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据流程实例id获取流程图染色数据
	 * @method
	 * @name #GetColorDataByProcessInstanceIdMapHeatPrivateV1ApiEgo_bpaGET
	 * @param {string} processInstanceId - processInstanceId
	 */
	public async GetColorDataByProcessInstanceIdMapHeatPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			processInstanceId?: string
		}
	}): Promise<typing.delegate.PlainResult$List$NodeColorBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/heat/map/getColorDataByProcessInstanceId'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		const result: typing.delegate.PlainResult$List$NodeColorBo$$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程key获取流程图染色数据
	 * @method
	 * @name #GetColorDataByProcessKeyMapHeatPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetColorDataByProcessKeyMapHeatPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessDetailParamBo
	}): Promise<typing.delegate.PlainResult$MapObject$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/heat/map/getColorDataByProcessKey'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程图
	 * @method
	 * @name #GetMapByProcessInstanceIdMapHeatPrivateV1ApiEgo_bpaGET
	 * @param {string} processInstanceId - processInstanceId
	 */
	public async GetMapByProcessInstanceIdMapHeatPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			processInstanceId?: string
		}
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/heat/map/getMapByProcessInstanceId'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['processInstanceId'] = params.query['processInstanceId']
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程key获取流程图
	 * @method
	 * @name #GetMapByProcessKeyMapHeatPrivateV1ApiEgo_bpaGET
	 * @param {string} processKey - processKey
	 */
	public async GetMapByProcessKeyMapHeatPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			processKey?: string
		}
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/heat/map/getMapByProcessKey'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processKey'] !== undefined) {
			queryParameters['processKey'] = params.query['processKey']
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程审批记录
	 * @method
	 * @name #GetTaskProcessListMapHeatPrivateV1ApiEgo_bpaGET
	 * @param {string} processInstanceId - process_instance_id
	 */
	public async GetTaskProcessListMapHeatPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			processInstanceId?: string
		}
	}): Promise<typing.delegate.PlainResult$TaskProcessListVo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/heat/map/getTaskProcessList'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['processInstanceId'] !== undefined) {
			queryParameters['process_instance_id'] = params.query['processInstanceId']
		}

		const result: typing.delegate.PlainResult$TaskProcessListVo$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 看板列表
	 * @method
	 * @name #PageKanbanPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async PageKanbanPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$BpaKanbanBo$
	}): Promise<typing.delegate.PageResult$BpaKanbanBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kanban/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$BpaKanbanBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 保存
	 * @method
	 * @name #SaveKanbanPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaKanbanBo - bpaKanbanBo
	 */
	public async SaveKanbanPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaKanbanBo
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kanban/save'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 订阅
	 * @method
	 * @name #SaveSubscribeKanbanPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaKanbanSubscribePo - bpaKanbanSubscribePo
	 */
	public async SaveSubscribeKanbanPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaKanbanSubscribePo
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kanban/saveSubscribe'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 选择表单
	 * @method
	 * @name #SelectFormKanbanPrivateV1ApiEgo_bpaGET
	 * @param {integer} kanbanId - kanbanId
	 */
	public async SelectFormKanbanPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			kanbanId?: number
		}
	}): Promise<typing.delegate.PlainResult$List$BpaFormPo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kanban/selectForm'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['kanbanId'] !== undefined) {
			queryParameters['kanbanId'] = params.query['kanbanId']
		}

		const result: typing.delegate.PlainResult$List$BpaFormPo$$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 更新
	 * @method
	 * @name #UpdateKanbanKanbanPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaKanbanBo - bpaKanbanBo
	 */
	public async UpdateKanbanKanbanPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaKanbanBo
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kanban/updateKanban'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * KPI管理列表
	 * @method
	 * @name #PageKpiPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async PageKpiPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$object$
	}): Promise<typing.delegate.PageResult$BpaKpiBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kpi/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$BpaKpiBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询
	 * @method
	 * @name #SelectKpiPrivateV1ApiEgo_bpaGET
	 */
	public async SelectKpiPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$List$BpaKpiBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/kpi/select'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$List$BpaKpiBo$$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程访问量数据
	 * @method
	 * @name #SelectPVCountAccessProcessPrivateV1ApiEgo_bpaGET
	 */
	public async SelectPVCountAccessProcessPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$ProcessPvCountResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/access/selectPVCount'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$ProcessPvCountResp$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程访问排名
	 * @method
	 * @name #SelectProcessPvRankingAccessProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessPvRankingAccessProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateRankingParam
	}): Promise<typing.delegate.PlainResult$List$AccessRankingResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/access/selectProcessPvRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$AccessRankingResp$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程访问趋势接口(可根据审批人查询)
	 * @method
	 * @name #SelectProcessPvTrendAccessProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessPvTrendAccessProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.AccessTrendParamBo
	}): Promise<typing.delegate.PlainResult$ReportFormResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/access/selectProcessPvTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ReportFormResp$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 导出流程列表Excel
	 * @method
	 * @name #ExportExcelDataProcessPrivateV1ApiEgo_bpaGET
	 * @param {string} endTime - end_time
	 * @param {string} startTime - start_time
	 */
	public async ExportExcelDataProcessPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			endTime?: string
			startTime?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/exportExcel'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['end_time'] = params.query['endTime']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['start_time'] = params.query['startTime']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程平均处理时间
	 * @method
	 * @name #GetAvgTimeDataDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaBaseBo - bpaBaseBo
	 */
	public async GetAvgTimeDataDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaBaseBo
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getAvgTimeData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程平均处理时间排名
	 * @method
	 * @name #GetProcessAvgTimeRankingDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetProcessAvgTimeRankingDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateRankingParam
	}): Promise<typing.delegate.PlainResult$ProcessRankingBo$AvgTimeBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessAvgTimeRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessRankingBo$AvgTimeBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程平均处理时间图表排名
	 * @method
	 * @name #GetProcessAvgTimeReportRankingDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetProcessAvgTimeReportRankingDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessReportRankingParam
	}): Promise<typing.delegate.PageResult$AvgTimeBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessAvgTimeReportRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$AvgTimeBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程平均处理时间趋势图
	 * @method
	 * @name #GetProcessAvgTimeTrendDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetProcessAvgTimeTrendDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessKeysParamBo
	}): Promise<typing.delegate.PlainResult$ProcessInitiateAvgTimeBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessAvgTimeTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessInitiateAvgTimeBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程发起数据
	 * @method
	 * @name #GetProcessInitiateDataDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} processInitiateParam - processInitiateParam
	 */
	public async GetProcessInitiateDataDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateParam
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessInitiateData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 填充当天24小时pv平均数据报表
	 * @method
	 * @name #GetProcessPvDataDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaBaseBo - bpaBaseBo
	 */
	public async GetProcessPvDataDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaBaseBo
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessPvData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程访问趋势图
	 * @method
	 * @name #GetProcessPvTrendDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetProcessPvTrendDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateTrendParam
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getProcessPvTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取运行中流程量
	 * @method
	 * @name #GetRunningProcessDataDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} bpaBaseBo - bpaBaseBo
	 */
	public async GetRunningProcessDataDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.BpaBaseBo
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/getRunningProcessData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程列表数据
	 * @method
	 * @name #ListProcessDataDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async ListProcessDataDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$ProcessInitiateRankingParam$
	}): Promise<typing.delegate.PageResult$ProcessListBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/listProcessData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ProcessListBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程发起排名数据
	 * @method
	 * @name #SelectProcessInitiateRankingDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessInitiateRankingDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateRankingParam
	}): Promise<typing.delegate.PlainResult$ProcessRankingBo$InitiateRankingResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/selectProcessInitiateRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessRankingBo$InitiateRankingResp$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程访问排名
	 * @method
	 * @name #SelectProcessPvRankingDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessPvRankingDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateRankingParam
	}): Promise<typing.delegate.PlainResult$ProcessRankingBo$AccessRankingResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/data/selectProcessPvRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessRankingBo$AccessRankingResp$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程数据
	 * @method
	 * @name #GetFlowInitiateDataProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} processInitiateParam - processInitiateParam
	 */
	public async GetFlowInitiateDataProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateParam
	}): Promise<typing.delegate.PlainResult$List$ProcessInitiateDataBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/getFlowInitiateData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ProcessInitiateDataBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程发起量
	 * @method
	 * @name #GetProcessInitiateCountProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} processInitiateParam - processInitiateParam
	 */
	public async GetProcessInitiateCountProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateParam
	}): Promise<typing.delegate.PlainResult$ProcessInitiateCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/getProcessInitiateCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessInitiateCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 下载导出的流程实例数据
	 * @method
	 * @name #DownloadProcessInstanceManageProcessPrivateV1ApiEgo_bpaGET
	 * @param {string} fileName - fileName
	 */
	public async DownloadProcessInstanceManageProcessPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			fileName?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/manage/downloadProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['fileName'] !== undefined) {
			queryParameters['fileName'] = params.query['fileName']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 导出流程实例数据
	 * @method
	 * @name #ExportProcessInstanceManageProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} request - request
	 */
	public async ExportProcessInstanceManageProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$SearchParam$
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/manage/exportProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 根据流程实例ID导出流程实例数据
	 * @method
	 * @name #ExportProcessInstanceByIdManageProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} request - request
	 */
	public async ExportProcessInstanceByIdManageProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessExportParam
	}): Promise<typing.delegate.PlainResult$string$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/manage/exportProcessInstanceById'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$string$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 搜索流程实例列表
	 * @method
	 * @name #SelectProcessInstanceManageProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessInstanceManageProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$SearchParam$
	}): Promise<typing.delegate.PageResult$SearchResultBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/manage/selectProcessInstance'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$SearchResultBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程分类树状图
	 * @method
	 * @name #SelectProcessTypeManageProcessPrivateV1ApiEgo_bpaGET
	 */
	public async SelectProcessTypeManageProcessPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$List$ProcessTypeViewResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/manage/selectProcessType'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$List$ProcessTypeViewResp$$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询根据字母分组排序的流程列表
	 * @method
	 * @name #LetterGroupListOldProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async LetterGroupListOldProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessNameParam
	}): Promise<typing.delegate.PlainResult$List$GroupListBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/letterGroupList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$GroupListBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询总流程发起量数据
	 * @method
	 * @name #SelectProcessInitiateCountOldProcessPrivateV1ApiEgo_bpaGET
	 */
	public async SelectProcessInitiateCountOldProcessPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$ProcessInitiateCountResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/selectProcessInitiateCount'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$ProcessInitiateCountResp$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程发起排名数据
	 * @method
	 * @name #SelectProcessInitiateRankingOldProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessInitiateRankingOldProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateRankingParam
	}): Promise<typing.delegate.PlainResult$List$InitiateRankingResp$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/selectProcessInitiateRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$InitiateRankingResp$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程发起趋势数据
	 * @method
	 * @name #SelectProcessInitiateTrendOldProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessInitiateTrendOldProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessInitiateTrendParam
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/selectProcessInitiateTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程列表
	 * @method
	 * @name #SelectProcessListOldProcessPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessListOldProcessPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessNameParam
	}): Promise<typing.delegate.PlainResult$List$GroupProcessBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/selectProcessList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$GroupProcessBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询所有流程类型
	 * @method
	 * @name #SelectProcessTypeListOldProcessPrivateV1ApiEgo_bpaGET
	 */
	public async SelectProcessTypeListOldProcessPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$List$ProcessResultBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/process/old/selectProcessTypeList'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$List$ProcessResultBo$$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * bpa_time表数据更新
	 * @method
	 * @name #AddBpaTimeScriptPrivateV1ApiEgo_bpaGET
	 * @param {string} endTime - endTime
	 * @param {string} startTime - startTime
	 */
	public async AddBpaTimeScriptPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			endTime?: string
			startTime?: string
		}
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/script/addBpaTime'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['endTime'] = params.query['endTime']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['startTime'] = params.query['startTime']
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * test
	 * @method
	 * @name #TestScriptPrivateV1ApiEgo_bpaGET
	 * @param {string} endTime - endTime
	 * @param {string} startTime - startTime
	 */
	public async TestScriptPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			endTime?: string
			startTime?: string
		}
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/script/test'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['endTime'] = params.query['endTime']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['startTime'] = params.query['startTime']
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 导出社交套件使用信息
	 * @method
	 * @name #ExportExcelKitSocialPrivateV1ApiEgo_bpaGET
	 * @param {string} endTime - end_time
	 * @param {string} startTime - start_time
	 */
	public async ExportExcelKitSocialPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			endTime?: string
			startTime?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_bpa/api/v1/private/social/kit/exportExcel'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['end_time'] = params.query['endTime']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['start_time'] = params.query['startTime']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 社交套件使用情况
	 * @method
	 * @name #SocialKitStatisticsKitSocialPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SocialKitStatisticsKitSocialPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.DateRangeParam
	}): Promise<typing.delegate.PlainResult$List$SocialKitStatsBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/social/kit/socialKitStatistics'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$SocialKitStatsBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 导出任务列表Excel
	 * @method
	 * @name #ExportExcelDataTaskPrivateV1ApiEgo_bpaGET
	 * @param {string} endTime - end_time
	 * @param {string} nodeNames - node_names
	 * @param {string} processKey - process_key
	 * @param {string} startTime - start_time
	 * @param {string} versions - versions
	 */
	public async ExportExcelDataTaskPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			endTime?: string
			nodeNames?: string
			processKey?: string
			startTime?: string
			versions?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/exportExcel'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['end_time'] = params.query['endTime']
		}

		if (params.query?.['nodeNames'] !== undefined) {
			queryParameters['node_names'] = params.query['nodeNames']
		}

		if (params.query?.['processKey'] !== undefined) {
			queryParameters['process_key'] = params.query['processKey']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['start_time'] = params.query['startTime']
		}

		if (params.query?.['versions'] !== undefined) {
			queryParameters['versions'] = params.query['versions']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取节点任务处理数据
	 * @method
	 * @name #GetNodeDisposeDataTrendDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetNodeDisposeDataTrendDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.NodeElapsedTimeReqBo
	}): Promise<typing.delegate.PlainResult$ReportFormResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getNodeDisposeDataTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ReportFormResp$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取节点平均耗时排名
	 * @method
	 * @name #GetNodeTaskAvgTimeRankingDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetNodeTaskAvgTimeRankingDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.NodeElapsedTimeReqBo
	}): Promise<typing.delegate.PageResult$NodeRankingBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getNodeTaskAvgTimeRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$NodeRankingBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取节点完成耗时数据
	 * @method
	 * @name #GetNodeTimeConsumingDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetNodeTimeConsumingDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.NodeElapsedTimeReqBo
	}): Promise<typing.delegate.PlainResult$NodeElapsedTimeBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getNodeTimeConsuming'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$NodeElapsedTimeBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务处理数据(实时数据)
	 * @method
	 * @name #GetRealTimeTaskDataDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetRealTimeTaskDataDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskRealTimeDataParamBo
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getRealTimeTaskData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务数据统计
	 * @method
	 * @name #GetTaskDataDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetTaskDataDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskDataCountBo
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getTaskData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取节点拒绝率排名
	 * @method
	 * @name #GetTaskNodeRejectPercentRankingDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetTaskNodeRejectPercentRankingDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.NodeElapsedTimeReqBo
	}): Promise<typing.delegate.PageResult$NodeRankingBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getTaskNodeRejectPercentRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$NodeRankingBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务处理趋势
	 * @method
	 * @name #GetTaskTrendDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetTaskTrendDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskTrendParamBo
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getTaskTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取待办任务数据
	 * @method
	 * @name #GetToDoTasksDataDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetToDoTasksDataDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskDataCountBo
	}): Promise<typing.delegate.PlainResult$DataCountBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/getToDoTasksData'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DataCountBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务数量统计列表
	 * @method
	 * @name #ListNodeDataCountDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async ListNodeDataCountDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$TaskCountParam$
	}): Promise<typing.delegate.PageResult$TaskCountResponse$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/listNodeDataCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskCountResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程的详情列表
	 * @method
	 * @name #ListProcessDetailDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async ListProcessDetailDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$ProcessDetailParamBo$
	}): Promise<typing.delegate.PlainResult$List$ProcessDetailBo$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/listProcessDetail'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ProcessDetailBo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取流程节点热力图数据
	 * @method
	 * @name #ListProcessNodeHotMapDataTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async ListProcessNodeHotMapDataTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessDetailParamBo
	}): Promise<typing.delegate.PlainResult$List$TaskCountResponse$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/data/listProcessNodeHotMap'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$TaskCountResponse$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询待办处理量数据
	 * @method
	 * @name #DisposeCountTaskPrivateV1ApiEgo_bpaGET
	 */
	public async DisposeCountTaskPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$ProcessDisposeCountResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/disposeCount'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$ProcessDisposeCountResp$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务数量统计
	 * @method
	 * @name #ListTaskCountTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async ListTaskCountTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$TaskCountParam$
	}): Promise<typing.delegate.PlainResult$List$TaskCountResponse$$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/listTaskCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$TaskCountResponse$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据审批人查询其任务的处理趋势
	 * @method
	 * @name #SelectAllTaskTrendByEmpTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectAllTaskTrendByEmpTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.AllTaskTrendParam
	}): Promise<typing.delegate.PlainResult$ReportFormResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectAllTaskTrendByEmp'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ReportFormResp$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程节点查询
	 * @method
	 * @name #SelectProcessNodeListTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessNodeListTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.NodeParam
	}): Promise<typing.delegate.PlainResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectProcessNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 流程版本号查询
	 * @method
	 * @name #SelectProcessVersionListTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectProcessVersionListTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessVersionParam
	}): Promise<typing.delegate.PlainResult$ProcessVersionResp$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectProcessVersionList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessVersionResp$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据审批人查询待办已办和预待办数量
	 * @method
	 * @name #SelectTaskByEmpTaskPrivateV1ApiEgo_bpaGET
	 * @param {string} employeeId - employee_id
	 */
	public async SelectTaskByEmpTaskPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			employeeId?: string
		}
	}): Promise<typing.delegate.PlainResult$UntreatedAndInitiateTaskBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectTaskByEmp'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['employeeId'] !== undefined) {
			queryParameters['employee_id'] = params.query['employeeId']
		}

		const result: typing.delegate.PlainResult$UntreatedAndInitiateTaskBo$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 审批绩效统计
	 * @method
	 * @name #SelectTaskCountByEmpTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectTaskCountByEmpTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$EmpTaskCountParam$
	}): Promise<typing.delegate.PageResult> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectTaskCountByEmp'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 审批绩效趋势
	 * @method
	 * @name #SelectTaskTrendByEmpTaskPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async SelectTaskTrendByEmpTaskPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskTrendBo
	}): Promise<typing.delegate.PlainResult$object$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/task/selectTaskTrendByEmp'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$object$ = await this.http.request(
			{
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			}
		)
		return result
	}
	/**
	 * 获取用户处理任务平均耗时排名
	 * @method
	 * @name #EmpTaskAvgTimeRankingDataUserPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async EmpTaskAvgTimeRankingDataUserPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskDisposeRankingParamBo
	}): Promise<typing.delegate.PageResult$EmpDataRankingBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/empTaskAvgTimeRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$EmpDataRankingBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取用户处理任务排名
	 * @method
	 * @name #EmpTaskDisposeRankingDataUserPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async EmpTaskDisposeRankingDataUserPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.TaskDisposeRankingParamBo
	}): Promise<typing.delegate.PageResult$EmpDataRankingBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/empTaskDisposeRanking'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$EmpDataRankingBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 导出用户数据统计列表Excel
	 * @method
	 * @name #ExportExcelDataUserPrivateV1ApiEgo_bpaGET
	 * @param {string} employeeId - employee_id
	 * @param {string} endTime - end_time
	 * @param {string} startTime - start_time
	 */
	public async ExportExcelDataUserPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			employeeId?: string
			endTime?: string
			startTime?: string
		}
	}): Promise<{}> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/exportExcel'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['employeeId'] !== undefined) {
			queryParameters['employee_id'] = params.query['employeeId']
		}

		if (params.query?.['endTime'] !== undefined) {
			queryParameters['end_time'] = params.query['endTime']
		}

		if (params.query?.['startTime'] !== undefined) {
			queryParameters['start_time'] = params.query['startTime']
		}

		const result: {} = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程用户平均处理时间趋势图
	 * @method
	 * @name #GetProcessAvgTimeTrendDataUserPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async GetProcessAvgTimeTrendDataUserPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.ProcessKeysParamBo
	}): Promise<typing.delegate.PlainResult$ProcessInitiateAvgTimeBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/getProcessAvgTimeTrend'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessInitiateAvgTimeBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取任务平均耗时面板数据
	 * @method
	 * @name #GetTaskAvgTimeDataUserPrivateV1ApiEgo_bpaPOST
	 * @param {} param - param
	 */
	public async GetTaskAvgTimeDataUserPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.EmpTaskCountParam
	}): Promise<typing.delegate.PlainResult$TaskAvgTimeBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/getTaskAvgTime'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$TaskAvgTimeBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取用户数据统计列表
	 * @method
	 * @name #ListUserDataCountDataUserPrivateV1ApiEgo_bpaPOST
	 * @param {} req - req
	 */
	public async ListUserDataCountDataUserPrivateV1ApiEgo_bpaPOST(params: {
		payload?: typing.delegate.PageRequest$DateRangeParam$
	}): Promise<typing.delegate.PageResult$ListUserDataBo$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/data/listUserDataCount'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ListUserDataBo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * deleteById
	 * @method
	 * @name #DeleteByIdRecordsUserPrivateV1ApiEgo_bpaGET
	 * @param {string} userId - user_id
	 */
	public async DeleteByIdRecordsUserPrivateV1ApiEgo_bpaGET(params: {
		query?: {
			userId?: string
		}
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/records/deleteById'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['userId'] !== undefined) {
			queryParameters['user_id'] = params.query['userId']
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * isFirstLogin
	 * @method
	 * @name #IsFirstLoginRecordsUserPrivateV1ApiEgo_bpaGET
	 */
	public async IsFirstLoginRecordsUserPrivateV1ApiEgo_bpaGET(params?: {}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_bpa/api/v1/private/user/records/isFirstLogin'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-批量终止
	 * @method
	 * @name #EndFlowCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async EndFlowCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TerminateProcessParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/endFlow'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-加签
	 * @method
	 * @name #EndorsementCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async EndorsementCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskEndorseRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/endorsement'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取指定历史节点列表
	 * @method
	 * @name #ListHistoryNodeCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ListHistoryNodeCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodesParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/historyNode/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回指定历史节点
	 * @method
	 * @name #RollbackHistoryNodeCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async RollbackHistoryNodeCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodeParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/historyNode/rollback'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回上一步
	 * @method
	 * @name #RollbackLastNodeCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async RollbackLastNodeCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/lastNode/rollback'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-重启
	 * @method
	 * @name #RestartCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async RestartCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/restart'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-跳过
	 * @method
	 * @name #SkipCommandV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async SkipCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/skip'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 批量转发
	 * @method
	 * @name #TransferCommandV2PecApiEgo_managePOST
	 * @param {} transferParam - transferParam
	 */
	public async TransferCommandV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/command/transfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取可重启的节点列表
	 * @method
	 * @name #GetAllNodeListV2PecApiEgo_managePOST
	 * @param {} param - param
	 */
	public async GetAllNodeListV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/getAllNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 运维日志-分页
	 * @method
	 * @name #LogListV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async LogListV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PageResult$ManageLogVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/logList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ManageLogVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 运维日志-系统日志类型
	 * @method
	 * @name #LogTypeListV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async LogTypeListV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PageResult$LogActionType$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/logTypeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$LogActionType$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 查询流程信息，默认返回前10条记录
	 * @method
	 * @name #ListProcessInfoV2PecApiEgo_managePOST
	 * @param {string} queryParam - queryParam
	 */
	public async ListProcessInfoV2PecApiEgo_managePOST(params: {
		query?: {
			queryParam?: string
		}
	}): Promise<typing.delegate.ListResult$ProcessInfoVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/processInfo/list'
		let body: any
		const queryParameters: any = {}

		if (params.query?.['queryParam'] !== undefined) {
			queryParameters['queryParam'] = params.query['queryParam']
		}

		const result: typing.delegate.ListResult$ProcessInfoVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程干预列表查询接口
	 * @method
	 * @name #GetProcessInstanceV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async GetProcessInstanceV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcOneQuery
	}): Promise<typing.delegate.PlainResult$ProcessInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/processInstance/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ProcessInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程干预列表查询接口
	 * @method
	 * @name #PageProcessInstanceV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async PageProcessInstanceV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PageResult$ProcessInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/processInstance/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ProcessInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取指定流程实例的任务集合
	 * @method
	 * @name #TaskListProcessInstanceV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async TaskListProcessInstanceV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PlainResult$List$TaskInstanceVo$$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/processInstance/taskList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$TaskInstanceVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 流程干预流程key范围查询
	 * @method
	 * @name #ListProcessKeyV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async ListProcessKeyV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PageResult$ProcessKeyVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/processKey/list'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$ProcessKeyVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-任务列表
	 * @method
	 * @name #GetTaskV2PecApiEgo_managePOST
	 * @param {} oneQuery - oneQuery
	 */
	public async GetTaskV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcOneQuery
	}): Promise<typing.delegate.PlainResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/task/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-任务列表
	 * @method
	 * @name #PageTaskV2PecApiEgo_managePOST
	 * @param {} pageQuery - pageQuery
	 */
	public async PageTaskV2PecApiEgo_managePOST(params: {
		payload?: typing.delegate.AppRunDataSvcPageQuery
	}): Promise<typing.delegate.PageResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/pec/v2/task/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 判断用户是否有操作权限
	 * @method
	 * @name #CheckFunctionAuthPrivateV1ApiEgo_managePOST
	 */
	public async CheckFunctionAuthPrivateV1ApiEgo_managePOST(params?: {}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_manage/api/v1/private/auth/checkFunction'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过ID获取用户菜单权限
	 * @method
	 * @name #SelectAllAuthenticationAuthPrivateV1ApiEgo_managePOST
	 */
	public async SelectAllAuthenticationAuthPrivateV1ApiEgo_managePOST(params?: {}): Promise<typing.delegate.ListResult$ManageMenuResponse$> {
		let path = ''
		path = '/ego_manage/api/v1/private/auth/selectAllAuthentication'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.ListResult$ManageMenuResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据用户查询所有的数据权限
	 * @method
	 * @name #SelectAllDataAuthAuthPrivateV1ApiEgo_managePOST
	 */
	public async SelectAllDataAuthAuthPrivateV1ApiEgo_managePOST(params?: {}): Promise<typing.delegate.PlainResult$List$ProcessInfoVo$$> {
		let path = ''
		path = '/ego_manage/api/v1/private/auth/selectAllDataAuth'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$List$ProcessInfoVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通过ID获取用户功能权限
	 * @method
	 * @name #SelectAllFunctionAuthPrivateV1ApiEgo_managePOST
	 */
	public async SelectAllFunctionAuthPrivateV1ApiEgo_managePOST(params?: {}): Promise<typing.delegate.ListResult$ManageFunctionResponse$> {
		let path = ''
		path = '/ego_manage/api/v1/private/auth/selectAllFunction'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.ListResult$ManageFunctionResponse$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-批量终止
	 * @method
	 * @name #BatchEndFlowProcessCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async BatchEndFlowProcessCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TerminateProcessParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/batchEndFlowProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 批量转发
	 * @method
	 * @name #BatchTransferCommandPrivateV1ApiEgo_managePOST
	 * @param {} transferParam - transferParam
	 */
	public async BatchTransferCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.ListResult$DevOpsExecuteLogDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/batchTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$DevOpsExecuteLogDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-任务列表
	 * @method
	 * @name #TransferListDoneCommandPrivateV1ApiEgo_managePOST
	 * @param {} transferParam - transferParam
	 */
	public async TransferListDoneCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.ListResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/done/transferList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.ListResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 已办任务交接转办
	 * @method
	 * @name #DoneTransferCommandPrivateV1ApiEgo_managePOST
	 * @param {} transferParam - transferParam
	 */
	public async DoneTransferCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.PlainResult$ExecuteLog$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/doneTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ExecuteLog$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-重新计算流程预览
	 * @method
	 * @name #ForecastRunCommandPrivateV1ApiEgo_managePOST
	 * @param {} req - req
	 */
	public async ForecastRunCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/forecastRun'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取可重启的节点列表
	 * @method
	 * @name #GetAllNodeListCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async GetAllNodeListCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/getAllNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-获取指定历史节点列表
	 * @method
	 * @name #GetRollbackHistoryNodeListCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async GetRollbackHistoryNodeListCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodesParam
	}): Promise<typing.delegate.PlainResult$List$ActivitNodeVo$$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/getRollbackHistoryNodeList'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ActivitNodeVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据流程实例id获取流程相关的信息
	 * @method
	 * @name #GrantAuthToAdminCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async GrantAuthToAdminCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodesParam
	}): Promise<typing.delegate.PlainResult$TaskInfoResultVo$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/grantAuthToAdmin'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$TaskInfoResultVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-流程人员流转
	 * @method
	 * @name #ManagerArbitrarilyProcessCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerArbitrarilyProcessCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerArbitrarilyProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-加签
	 * @method
	 * @name #ManagerEndorsementProcessCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerEndorsementProcessCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskEndorseRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerEndorsementProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-重启
	 * @method
	 * @name #ManagerRestartProcessCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerRestartProcessCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerRestartProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回指定历史节点
	 * @method
	 * @name #ManagerRollbackToHistoryNodeCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerRollbackToHistoryNodeCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskRollBackHistoryNodeParam
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerRollbackToHistoryNode'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-退回上一步
	 * @method
	 * @name #ManagerRollbackToLastCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerRollbackToLastCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerRollbackToLast'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 任务干预-跳过
	 * @method
	 * @name #ManagerSkipProcessCommandPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async ManagerSkipProcessCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskInterveneRequest
	}): Promise<typing.delegate.PlainResult$DevOpsRunProcessDto$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/managerSkipProcess'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$DevOpsRunProcessDto$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 待办任务交接转办
	 * @method
	 * @name #TodoTransferCommandPrivateV1ApiEgo_managePOST
	 * @param {} transferParam - transferParam
	 */
	public async TodoTransferCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskTransferParam
	}): Promise<typing.delegate.PlainResult$ExecuteLog$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/todoTransfer'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$ExecuteLog$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 管理操作-查询瞬时变量
	 * @method
	 * @name #TransientVariableCommandPrivateV1ApiEgo_managePOST
	 * @param {} req - req
	 */
	public async TransientVariableCommandPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.ReStartProcessParam
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_manage/api/v1/private/command/transientVariable'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 检查用户A能否替换给用户B
	 * @method
	 * @name #CheckUserAToUserBSysPrivateV1ApiEgo_managePOST
	 * @param {} assigneeReplaceDto - assigneeReplaceDto
	 */
	public async CheckUserAToUserBSysPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.AssigneeReplaceDto
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_manage/api/v1/private/sys/checkUserAToUserB'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据taskIds导出任务
	 * @method
	 * @name #BatchExportTaskTaskPrivateV1ApiEgo_managePOST
	 * @param {} param - param
	 */
	public async BatchExportTaskTaskPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.BatchExportTaskParam
	}): Promise<{}> {
		let path = ''
		path = '/ego_manage/api/v1/private/task/batchExportTask'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: {} = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 获取流程下的任务集合
	 * @method
	 * @name #GetTaskListEntityTaskPrivateV1ApiEgo_managePOST
	 * @param {} taskListQueryParam - taskListQueryParam
	 */
	public async GetTaskListEntityTaskPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskListQueryParam
	}): Promise<typing.delegate.PlainResult$List$TaskInstanceVo$$> {
		let path = ''
		path = '/ego_manage/api/v1/private/task/getTaskListEntity'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$TaskInstanceVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 根据当前登录用户拥有的流程权限查询相关的任务
	 * @method
	 * @name #PageTaskPrivateV1ApiEgo_managePOST
	 * @param {} queryParam - queryParam
	 */
	public async PageTaskPrivateV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.TaskQueryParam
	}): Promise<typing.delegate.PageResult$TaskInstanceVo$> {
		let path = ''
		path = '/ego_manage/api/v1/private/task/page'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PageResult$TaskInstanceVo$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取当前登录用户的信息
	 * @method
	 * @name #GetUserInfoUserPrivateV1ApiEgo_manageGET
	 */
	public async GetUserInfoUserPrivateV1ApiEgo_manageGET(params?: {}): Promise<typing.delegate.PlainResult$CurrentCacheUser$> {
		let path = ''
		path = '/ego_manage/api/v1/private/user/getUserInfo'
		let body: any
		const queryParameters: any = {}

		const result: typing.delegate.PlainResult$CurrentCacheUser$ =
			await this.http.request({
				method: 'GET',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 模糊查询，默认返回前1000条
	 * @method
	 * @name #SelectAllFlowTypeProcessTypePublicV1ApiEgo_managePOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectAllFlowTypeProcessTypePublicV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<Array<typing.delegate.ProcessTypePo>> {
		let path = ''
		path = '/ego_manage/api/v1/public/processType/selectAllFlowType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: Array<typing.delegate.ProcessTypePo> =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 模糊查询，默认返回前1000条
	 * @method
	 * @name #SelectFlowTypeProcessTypePublicV1ApiEgo_managePOST
	 * @param {} requestBean - requestBean
	 */
	public async SelectFlowTypeProcessTypePublicV1ApiEgo_managePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PlainResult$List$ProcessInfoVo$$> {
		let path = ''
		path = '/ego_manage/api/v1/public/processType/selectFlowType'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$List$ProcessInfoVo$$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 本地测试发送
	 * @method
	 * @name #SendEmailMessageV1ApiEgo_messagePOST
	 * @param {} requestDto - requestDto
	 */
	public async SendEmailMessageV1ApiEgo_messagePOST(params: {
		payload?: typing.delegate.RequestApiBean
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/api/v1/message/sendEmail'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 发送邀请加入百特搭的通知短信
	 * @method
	 * @name #InvitationSmsV1ApiEgo_messagePOST
	 * @param {} req - req
	 */
	public async InvitationSmsV1ApiEgo_messagePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/api/v1/sms/invitation'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 通用的短信发送接口
	 * @method
	 * @name #SendSmsV1ApiEgo_messagePOST
	 * @param {} sendSmsRequest - sendSmsRequest
	 */
	public async SendSmsV1ApiEgo_messagePOST(params: {
		payload?: typing.delegate.SendSmsRequest
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/api/v1/sms/send'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 发送验证码短信
	 * @method
	 * @name #VerifyCodeSmsV1ApiEgo_messagePOST
	 * @param {} req - req
	 */
	public async VerifyCodeSmsV1ApiEgo_messagePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/api/v1/sms/verify-code'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * commonCardMessage
	 * @method
	 * @name #CommonCardMessageMessageV1SpEgo_messagePOST
	 * @param {} paramRequestBean - paramRequestBean
	 */
	public async CommonCardMessageMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<{}> {
		let path = ''
		path = '/ego_message/sp/v1/message/commonCardMessage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: {} = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * commonCardMessageToReceivers
	 * @method
	 * @name #CommonCardMessageToReceiversMessageV1SpEgo_messagePOST
	 * @param {} paramRequestBean - paramRequestBean
	 */
	public async CommonCardMessageToReceiversMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<{}> {
		let path = ''
		path = '/ego_message/sp/v1/message/commonCardMessageToReceivers'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: {} = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 创建群
	 * @method
	 * @name #CreateMessageV1SpEgo_messagePOST
	 * @param {} chatInfo - chatInfo
	 */
	public async CreateMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.GroupChatVo
	}): Promise<string> {
		let path = ''
		path = '/ego_message/sp/v1/message/create'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 自定义IM发消息
	 * @method
	 * @name #CreateGroupCustomMessageV1SpEgo_messagePOST
	 * @param {} requestDto - requestDto
	 */
	public async CreateGroupCustomMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.HttpMessageDto
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_message/sp/v1/message/custom/group/create'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 自定义IM发消息
	 * @method
	 * @name #UpdateGroupCustomMessageV1SpEgo_messagePOST
	 * @param {} requestDto - requestDto
	 */
	public async UpdateGroupCustomMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.HttpMessageDto
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/sp/v1/message/custom/group/update'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 自定义IM发消息
	 * @method
	 * @name #SendCustomMessageV1SpEgo_messagePOST
	 * @param {} requestDto - requestDto
	 */
	public async SendCustomMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.HttpMessageDto
	}): Promise<typing.delegate.PlainResult$MapObject$> {
		let path = ''
		path = '/ego_message/sp/v1/message/custom/send'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$MapObject$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 获取群信息
	 * @method
	 * @name #GetMessageV1SpEgo_messagePOST
	 * @param {} chatIdDto - chatIdDto
	 */
	public async GetMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.ChatIdRequestVo
	}): Promise<typing.delegate.GroupChatInfo> {
		let path = ''
		path = '/ego_message/sp/v1/message/get'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.GroupChatInfo = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 消息提醒
	 * @method
	 * @name #ProcessRemindMessageV1SpEgo_messagePOST
	 * @param {} processMessageVo - processMessageVo
	 */
	public async ProcessRemindMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.ProcessMessageVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_message/sp/v1/message/processRemind'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 发送群消息
	 * @method
	 * @name #SendMessageV1SpEgo_messagePOST
	 * @param {} groupMessageVo - groupMessageVo
	 */
	public async SendMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.GroupMessageVO
	}): Promise<string> {
		let path = ''
		path = '/ego_message/sp/v1/message/send'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 消息提醒
	 * @method
	 * @name #SendCustomMessageMessageV1SpEgo_messagePOST
	 * @param {} messageDto - messageDto
	 */
	public async SendCustomMessageMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.CustomMessageParam
	}): Promise<boolean> {
		let path = ''
		path = '/ego_message/sp/v1/message/sendCustomMessage'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 待办Lark
	 * @method
	 * @name #SingleToBeApproveMessageV1SpEgo_messagePOST
	 * @param {} toBeApproveVo - toBeApproveVo
	 */
	public async SingleToBeApproveMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.SingleToBeApproveVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_message/sp/v1/message/singleToBeApprove'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * test
	 * @method
	 * @name #TestMessageV1SpEgo_messagePOST
	 * @param {} testInfo - testInfo
	 */
	public async TestMessageV1SpEgo_messagePOST(params: {
		payload?: string
	}): Promise<boolean> {
		let path = ''
		path = '/ego_message/sp/v1/message/test'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 本地测试发送
	 * @method
	 * @name #TestSendVoMessageV1SpEgo_messagePOST
	 * @param {} requestDto - requestDto
	 */
	public async TestSendVoMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.RequestBean
	}): Promise<typing.delegate.PlainResult$boolean$> {
		let path = ''
		path = '/ego_message/sp/v1/message/testSendVo'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: typing.delegate.PlainResult$boolean$ =
			await this.http.request({
				method: 'POST',
				url: path,
				params: queryParameters,
				payload: body,
			})
		return result
	}
	/**
	 * 发送待办Lark
	 * @method
	 * @name #ToBeApproveMessageV1SpEgo_messagePOST
	 * @param {} toBeApproveVo - toBeApproveVo
	 */
	public async ToBeApproveMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.ToBeApproveVo
	}): Promise<boolean> {
		let path = ''
		path = '/ego_message/sp/v1/message/toBeApprove'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: boolean = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * 修改群
	 * @method
	 * @name #UpdateMessageV1SpEgo_messagePOST
	 * @param {} memberInfo - memberInfo
	 */
	public async UpdateMessageV1SpEgo_messagePOST(params: {
		payload?: typing.delegate.GroupMemberVo
	}): Promise<string> {
		let path = ''
		path = '/ego_message/sp/v1/message/update'
		let body: any
		const queryParameters: any = {}

		if (params.payload !== undefined) {
			body = params.payload
		}

		const result: string = await this.http.request({
			method: 'POST',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
	/**
	 * apiHealthCheck
	 * @method
	 * @name #HealthActuatorFlowRuntimeGET
	 */
	public async HealthActuatorFlowRuntimeGET(params?: {}): Promise<string> {
		let path = ''
		path = '/flow-runtime/actuator/health'
		let body: any
		const queryParameters: any = {}

		const result: string = await this.http.request({
			method: 'GET',
			url: path,
			params: queryParameters,
			payload: body,
		})
		return result
	}
}
